Teams App Developer

import { App } from "@slack/bolt";

const app = new App({
  token: process.env.SLACK_BOT_TOKEN!,
  signingSecret: process.env.SLACK_SIGNING_SECRET!,
  // Built-in retry handling
  retryConfig: {
    retries: 3,
    factor: 2, // exponential backoff
  },
});

// Bolt automatically retries on 429
app.message(/hello/i, async ({ say }) => {
  await say("Hello!"); // auto-retried on rate limit
});

import { App } from "@microsoft/teams.apps";
import { ConsoleLogger } from "@microsoft/teams.common";

const logger = new ConsoleLogger("my-bot", { level: "info" });

const app = new App({
  logger,
});

// Exponential backoff with jitter — replaces Bolt's retryConfig
async function withRetry<T>(
  fn: () => Promise<T>,
  options: {
    maxRetries?: number;
    baseDelayMs?: number;
    maxDelayMs?: number;
    jitterMs?: number;
  } = {}
): Promise<T> {
  const {
    maxRetries = 3,
    baseDelayMs = 1000,
    maxDelayMs = 30_000,
    jitterMs = 500,
  } = options;

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (err: any) {
      const status = err?.statusCode ?? err?.response?.status ?? err?.code;
      const isRetryable = status === 429 || status === 503 || status === 502;

      if (!isRetryable || attempt === maxRetries) {
        throw err;
      }

      // Use Retry-After header if available, otherwise exponential backoff
      const retryAfterSec = err?.response?.headers?.["retry-after"];
      let delay: number;

      if (retryAfterSec) {
        delay = parseInt(retryAfterSec, 10) * 1000;
      } else {
        delay = Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
      }

      // Add jitter to prevent thundering herd
      delay += Math.random() * jitterMs;

      logger.warn(
        `Rate limited (attempt ${attempt + 1}/${maxRetries}). ` +
        `Retrying in ${Math.round(delay)}ms...`
      );

      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }

  throw new Error("withRetry: unreachable");
}

// Usage: wrap any API call that might be rate limited
app.message(/hello/i, async ({ send }) => {
  await withRetry(() => send("Hello!"));
});

app.start(3978);

import { App } from "@slack/bolt";

const app = new App({
  token: process.env.SLACK_BOT_TOKEN!,
  signingSecret: process.env.SLACK_SIGNING_SECRET!,
});

// Broadcast to all channels — Bolt retries handle 429s
app.command("/broadcast", async ({ ack, command, client }) => {
  await ack();
  const channels = await client.conversations.list({ types: "public_channel" });

  for (const channel of channels.channels ?? []) {
    try {
      await client.chat.postMessage({
        channel: channel.id!,
        text: command.text,
      });
    } catch (err: any) {
      if (err.data?.error === "ratelimited") {
        const retryAfter = parseInt(err.data.response_metadata?.retry_after ?? "1", 10);
        await new Promise((r) => setTimeout(r, retryAfter * 1000));
        await client.chat.postMessage({ channel: channel.id!, text: command.text });
      }
    }
  }
});

import { App } from "@microsoft/teams.apps";
import { ConsoleLogger } from "@microsoft/teams.common";
import PQueue from "p-queue";

const logger = new ConsoleLogger("my-bot", { level: "info" });
const app = new App({ logger });

// Store conversation references at install time
const conversationRefs = new Map<string, {
  conversationId: string;
  serviceUrl: string;
}>();

app.on("install.add", async ({ activity }) => {
  const convId = activity.conversation?.id ?? "";
  conversationRefs.set(convId, {
    conversationId: convId,
    serviceUrl: (activity as any).serviceUrl,
  });
});

// Rate-limited broadcast queue
// Concurrency: 5 simultaneous sends, 200ms between each
const sendQueue = new PQueue({
  concurrency: 5,
  interval: 200,
  intervalCap: 1, // 1 task per interval per concurrency slot
});

app.message(/^\/?broadcast (.+)$/i, async ({ send, activity }) => {
  const text = activity.text?.replace(/^\/?broadcast\s+/i, "") ?? "";
  const targets = Array.from(conversationRefs.values());

  await send(`Broadcasting to ${targets.length} conversations...`);

  let sent = 0;
  let failed = 0;

  const promises = targets.map((ref) =>
    sendQueue.add(async () => {
      try {
        await withRetry(() => app.send(ref.conversationId, text));
        sent++;
      } catch (err) {
        failed++;
        logger.error(`Failed to send to ${ref.conversationId}:`, err);
      }
    })
  );

  await Promise.all(promises);
  await send(`Broadcast complete: ${sent} sent, ${failed} failed.`);
});

// withRetry from previous pattern
async function withRetry<T>(fn: () => Promise<T>): Promise<T> {
  for (let attempt = 0; attempt < 3; attempt++) {
    try {
      return await fn();
    } catch (err: any) {
      const status = err?.statusCode ?? err?.response?.status;
      if (status !== 429 || attempt === 2) throw err;
      const retryAfter = parseInt(err?.response?.headers?.["retry-after"] ?? "2", 10);
      await new Promise((r) => setTimeout(r, retryAfter * 1000 + Math.random() * 500));
    }
  }
  throw new Error("unreachable");
}

app.start(3978);

import CircuitBreaker from "opossum";

// Wrap an external API call with a circuit breaker
const fetchUserData = new CircuitBreaker(
  async (userId: string) => {
    const response = await fetch(`https://api.internal.com/users/${userId}`);
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    return response.json();
  },
  {
    timeout: 5000,       // If the function takes longer than 5s, trigger a failure
    errorThresholdPercentage: 50, // Open circuit when 50% of requests fail
    resetTimeout: 30_000, // After 30s, try again (half-open)
    volumeThreshold: 5,  // Minimum 5 requests before evaluating threshold
  }
);

// Circuit events for monitoring
fetchUserData.on("open", () => logger.warn("Circuit OPEN — failing fast"));
fetchUserData.on("halfOpen", () => logger.info("Circuit HALF-OPEN — testing"));
fetchUserData.on("close", () => logger.info("Circuit CLOSED — normal operation"));

// Usage in a handler
app.message(/^\/?user (.+)$/i, async ({ send, activity }) => {
  const userId = activity.text?.match(/user\s+(\S+)/)?.[1] ?? "";
  try {
    const user = await fetchUserData.fire(userId);
    await send(`User: ${user.name} (${user.email})`);
  } catch (err: any) {
    if (err.message === "Breaker is open") {
      await send("The user service is temporarily unavailable. Please try again later.");
    } else {
      await send(`Error fetching user: ${err.message}`);
    }
  }
});

// Production retry utility — apply to all outbound calls
async function withRetry<T>(fn: () => Promise<T>, maxRetries = 3): Promise<T> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (err: any) {
      if (attempt === maxRetries) throw err;
      const retryAfter = err?.response?.headers?.["retry-after"];
      const baseDelay = retryAfter ? parseInt(retryAfter) * 1000 : 1000 * 2 ** attempt;
      const jitter = Math.random() * 1000;
      await new Promise(r => setTimeout(r, baseDelay + jitter));
    }
  }
  throw new Error("Unreachable");
}

// Proactive broadcast with concurrency control
import PQueue from "p-queue";

const broadcastQueue = new PQueue({ concurrency: 5, interval: 200, intervalCap: 1 });

async function broadcastToAll(
  conversationIds: string[],
  message: string
): Promise<{ sent: number; failed: number }> {
  let sent = 0, failed = 0;

  const promises = conversationIds.map(convId =>
    broadcastQueue.add(async () => {
      try {
        await withRetry(() => app.send(convId, message));
        sent++;
      } catch {
        failed++;
      }
    })
  );

  await Promise.all(promises);
  return { sent, failed };
}