@breadstone/archipel-mcp 0.0.45 → 0.0.47

package/data/guides/ai-text-generation.md

@@ -64,7 +64,7 @@ Register only the provider loaders you install. The root entry does not import p
 
 All intelligence settings are read from environment variables via `ConfigService`. No direct `process.env` access is needed.
 
-```env
+```dotenv
 INTELLIGENCE_PROVIDER=openai
 INTELLIGENCE_MODEL=gpt-4o-mini
 INTELLIGENCE_API_KEY=sk-...
@@ -85,7 +85,7 @@ INTELLIGENCE_BASE_URL=              # optional — override for custom endpoints
 
 Each provider resolves its API key and base URL from dedicated environment variables when the generic `INTELLIGENCE_API_KEY` is not set:
 
-```env
+```dotenv
 # Provider-specific keys (optional — fallback from INTELLIGENCE_API_KEY)
 OPENAI_API_KEY=sk-...
 ANTHROPIC_API_KEY=sk-ant-...

package/data/guides/authentication-and-authorization.md

@@ -475,7 +475,7 @@ If `mfaRequired` is `true`, the client receives a `challengeId` instead of an `a
 
 ### MFA Configuration
 
-```env
+```dotenv
 AUTH_MFA_ENCRYPTION_KEY=<32-byte-hex-key>
 AUTH_MFA_CHALLENGE_EXPIRES_IN=5m
 AUTH_MFA_MAX_ATTEMPTS=5
@@ -584,7 +584,7 @@ AuthModule.register({
 
 ### Step 4: Set Environment Variables
 
-```env
+```dotenv
 # Google
 AUTH_GOOGLE_CLIENT_ID=your-client-id
 AUTH_GOOGLE_CLIENT_SECRET=your-client-secret

package/data/guides/blob-storage.md

@@ -54,7 +54,7 @@ Each provider reads its credentials from environment variables via the `ConfigMo
 
 ### AWS S3
 
-```env
+```dotenv
 BLOB_AWS_REGION=eu-central-1
 BLOB_AWS_BUCKET=my-app-uploads
 BLOB_AWS_ACCESS_KEY_ID=AKIA...
@@ -67,7 +67,7 @@ BLOB_AWS_SECRET_ACCESS_KEY=secret...
 
 You can authenticate with either a **connection string** or **DefaultAzureCredential** (via managed identity):
 
-```env
+```dotenv
 # Option 1: Connection string
 BLOB_AZURE_CONNECTION_STRING=DefaultEndpointsProtocol=https;AccountName=...
 BLOB_AZURE_CONTAINER=uploads
@@ -83,7 +83,7 @@ When using `accountName` without a `connectionString`, the provider authenticate
 
 ### Vercel Blob
 
-```env
+```dotenv
 BLOB_VERCEL_TOKEN=your-vercel-blob-token
 ```
 

package/data/guides/caching.md

@@ -28,7 +28,7 @@ yarn add ioredis
 
 ### Core Variables
 
-```env
+```dotenv
 CACHE_DEFAULT_TTL_MS=60000
 CACHE_MAX_ENTRIES=1000
 CACHE_STALE_WHILE_REVALIDATE=false
@@ -38,7 +38,7 @@ All core variables are optional. When omitted, each cache instance uses the valu
 
 ### Redis Variables
 
-```env
+```dotenv
 REDIS_URL=redis://localhost:6379
 REDIS_KEY_PREFIX=app:
 REDIS_TTL_SECONDS=300

package/data/guides/composition-context.md

@@ -0,0 +1,462 @@
+---
+title: Composition Context
+description: Stage-aware, configuration-driven module composition for NestJS applications without direct process.env access.
+order: 4
+---
+
+# Composition Context
+
+The composition context pattern enables **stage-aware infrastructure module selection** at application startup. Rather than hard-coding provider imports or scattering `process.env` checks throughout your codebase, composition provides a clean abstraction that reads configuration once and determines which modules to import.
+
+This is particularly valuable for:
+
+- **Multi-stage deployments** — Use mock mail in development, real SMTP in production
+- **Feature flags** — Toggle entire modules based on configuration
+- **Provider switching** — Swap payment providers or blob storage backends per environment
+- **Clean architecture** — Keep `main.ts` free of conditional logic
+
+---
+
+## Installation
+
+The composition subpath is part of `platform-bootstrap`:
+
+```bash
+yarn add @breadstone/archipel-platform-bootstrap @breadstone/archipel-platform-configuration
+```
+
+---
+
+## Core Concepts
+
+### Composition Context
+
+The `ICompositionContext` provides typed access to configuration during module assembly:
+
+```typescript
+interface ICompositionContext {
+  readonly context: INestApplicationContext;
+  readonly config: ConfigService;
+
+  getConfigValue<T>(key: IConfigKey<T>): T;
+  tryGetConfigValue<T>(key: IConfigKey<T>, fallback: T): T;
+  getService<T>(token: Type<T>): T;
+  close(): Promise<void>;
+}
+```
+
+### Composition Resolver
+
+Abstract base class for encapsulating composition decisions:
+
+```typescript
+abstract class CompositionResolver {
+  abstract shouldImportProvider(providerKey: string): boolean;
+
+  protected getConfigValue<T>(key: IConfigKey<T>): T;
+  protected tryGetConfigValue<T>(key: IConfigKey<T>, fallback: T): T;
+  protected compareConfigValue<T>(key: IConfigKey<T>, expected: T): boolean;
+}
+```
+
+### Composition Import
+
+Type alias for valid NestJS module imports:
+
+```typescript
+type CompositionImport = Type<unknown> | DynamicModule | Promise<DynamicModule> | ForwardReference<unknown>;
+```
+
+---
+
+## Basic Usage
+
+### Direct Factory Approach
+
+For simple cases, use `createCompositionContext()` directly:
+
+```typescript
+import { NestFactory } from '@nestjs/core';
+import { createCompositionContext } from '@breadstone/archipel-platform-bootstrap/composition';
+import { AppModule } from './AppModule';
+
+async function main(): Promise<void> {
+  const context = await createCompositionContext();
+
+  try {
+    const driver = context.tryGetConfigValue({ key: 'MAIL_DRIVER' }, 'log');
+
+    if (driver === 'smtp') {
+      // Dynamic import only when needed
+      const { MailModule } = await import('@breadstone/archipel-platform-mailing');
+      const { SmtpDeliveryStrategy } = await import('@breadstone/archipel-platform-mailing/delivering/smtp');
+
+      console.log('Using SMTP mail delivery');
+    }
+  } finally {
+    await context.close();
+  }
+
+  // Continue with normal NestJS bootstrap
+  const app = await NestFactory.create(AppModule);
+  await app.listen(3000);
+}
+```
+
+### Builder Integration
+
+For full integration with `PlatformApplicationBuilder`:
+
+```typescript
+import { PlatformApplicationBuilder, useApi, CompositionImport } from '@breadstone/archipel-platform-bootstrap';
+import { ExpressAdapter, NestExpressApplication } from '@nestjs/platform-express';
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './AppModule';
+
+async function main(): Promise<void> {
+  const builder = await PlatformApplicationBuilder.createWithComposition<NestExpressApplication>(
+    async (context) => {
+      const imports: CompositionImport[] = [AppModule];
+
+      // Stage-aware mail provider selection
+      const driver = context.tryGetConfigValue({ key: 'MAIL_DRIVER' }, 'log');
+      const stage = context.tryGetConfigValue({ key: 'NODE_ENV' }, 'development');
+
+      if (driver === 'smtp' || stage === 'production') {
+        const { MailModule } = await import('@breadstone/archipel-platform-mailing');
+        const { SmtpDeliveryStrategy } = await import('@breadstone/archipel-platform-mailing/delivering/smtp');
+        imports.push(MailModule.register({ deliveryStrategy: SmtpDeliveryStrategy }));
+      } else {
+        const { MailModule } = await import('@breadstone/archipel-platform-mailing');
+        const { LogDeliveryStrategy } = await import('@breadstone/archipel-platform-mailing/delivering/log');
+        imports.push(MailModule.register({ deliveryStrategy: LogDeliveryStrategy }));
+      }
+
+      return imports;
+    },
+    {
+      appFactory: (module) => NestFactory.create<NestExpressApplication>(module, new ExpressAdapter()),
+    }
+  );
+
+  await builder
+    .use(useApi({ prefix: 'api' }))
+    .listenFromConfig({ fallbackPort: 3000 });
+}
+
+void main();
+```
+
+---
+
+## Custom Composition Resolver
+
+For complex applications, encapsulate composition logic in a dedicated resolver class:
+
+### 1. Define the Resolver
+
+```typescript
+// src/composition/AppCompositionResolver.ts
+import { Injectable } from '@nestjs/common';
+import { ConfigService, createConfigKey } from '@breadstone/archipel-platform-configuration';
+import { CompositionResolver } from '@breadstone/archipel-platform-bootstrap/composition';
+
+const MAIL_DRIVER = createConfigKey<string>('MAIL_DRIVER');
+const NODE_ENV = createConfigKey<string>('NODE_ENV');
+const FEATURE_NEW_PAYMENTS = createConfigKey<string>('FEATURE_NEW_PAYMENTS');
+
+@Injectable()
+export class AppCompositionResolver extends CompositionResolver {
+  public constructor(configService: ConfigService) {
+    super(configService);
+  }
+
+  public shouldImportProvider(providerKey: string): boolean {
+    switch (providerKey) {
+      case 'smtp-mail':
+        return this.shouldUseSmtpMail();
+      case 'log-mail':
+        return !this.shouldUseSmtpMail();
+      case 'stripe-payments':
+        return this.shouldUseStripePayments();
+      case 'paddle-payments':
+        return !this.shouldUseStripePayments();
+      default:
+        return false;
+    }
+  }
+
+  public shouldUseSmtpMail(): boolean {
+    const driver = this.tryGetConfigValue(MAIL_DRIVER, 'log');
+    return driver === 'smtp' || this.isProductionLike();
+  }
+
+  public shouldUseStripePayments(): boolean {
+    const feature = this.tryGetConfigValue(FEATURE_NEW_PAYMENTS, 'disabled');
+    return feature !== 'paddle';
+  }
+
+  public isProductionLike(): boolean {
+    const stage = this.tryGetConfigValue(NODE_ENV, 'development');
+    return stage === 'production' || stage === 'staging';
+  }
+}
+```
+
+### 2. Create a Composition Module
+
+```typescript
+// src/composition/AppCompositionModule.ts
+import { Module } from '@nestjs/common';
+import { ConfigModule, EnvironmentConfigStrategy } from '@breadstone/archipel-platform-configuration';
+import { AppCompositionResolver } from './AppCompositionResolver';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      strategyFactory: () => new EnvironmentConfigStrategy(),
+    }),
+  ],
+  providers: [AppCompositionResolver],
+  exports: [ConfigModule, AppCompositionResolver],
+})
+export class AppCompositionModule {}
+```
+
+### 3. Use in Bootstrap
+
+```typescript
+// src/main.ts
+import { PlatformApplicationBuilder, CompositionImport } from '@breadstone/archipel-platform-bootstrap';
+import { AppCompositionModule, AppCompositionResolver } from './composition';
+import { AppModule } from './AppModule';
+
+async function main(): Promise<void> {
+  const builder = await PlatformApplicationBuilder.createWithComposition(
+    async (context) => {
+      const resolver = context.getService(AppCompositionResolver);
+      const imports: CompositionImport[] = [AppModule];
+
+      // Mail provider
+      if (resolver.shouldImportProvider('smtp-mail')) {
+        const { MailModule } = await import('@breadstone/archipel-platform-mailing');
+        const { SmtpDeliveryStrategy } = await import('@breadstone/archipel-platform-mailing/delivering/smtp');
+        imports.push(MailModule.register({ deliveryStrategy: SmtpDeliveryStrategy }));
+      } else {
+        const { MailModule } = await import('@breadstone/archipel-platform-mailing');
+        const { LogDeliveryStrategy } = await import('@breadstone/archipel-platform-mailing/delivering/log');
+        imports.push(MailModule.register({ deliveryStrategy: LogDeliveryStrategy }));
+      }
+
+      // Payment provider
+      if (resolver.shouldImportProvider('stripe-payments')) {
+        const { PaymentModule } = await import('@breadstone/archipel-platform-payments');
+        const { StripeClient } = await import('@breadstone/archipel-platform-payments/stripe');
+        imports.push(PaymentModule.register({ paymentClient: StripeClient }));
+      } else if (resolver.shouldImportProvider('paddle-payments')) {
+        const { PaymentModule } = await import('@breadstone/archipel-platform-payments');
+        const { PaddleClient } = await import('@breadstone/archipel-platform-payments/paddle');
+        imports.push(PaymentModule.register({ paymentClient: PaddleClient }));
+      }
+
+      return imports;
+    },
+    {
+      compositionModule: AppCompositionModule,
+    }
+  );
+
+  await builder.listenFromConfig({ fallbackPort: 3000 });
+}
+```
+
+---
+
+## Provider Composer Pattern
+
+For reusable provider composition, define composer functions:
+
+```typescript
+// src/composition/composers/composeMailProvider.ts
+import type { ICompositionContext } from '@breadstone/archipel-platform-bootstrap/composition';
+import type { CompositionImport } from '@breadstone/archipel-platform-bootstrap';
+import { AppCompositionResolver } from '../AppCompositionResolver';
+
+export async function composeMailProvider(context: ICompositionContext): Promise<CompositionImport | null> {
+  const resolver = context.getService(AppCompositionResolver);
+
+  if (resolver.shouldImportProvider('smtp-mail')) {
+    const { MailModule } = await import('@breadstone/archipel-platform-mailing');
+    const { SmtpDeliveryStrategy } = await import('@breadstone/archipel-platform-mailing/delivering/smtp');
+    return MailModule.register({ deliveryStrategy: SmtpDeliveryStrategy });
+  }
+
+  if (resolver.shouldImportProvider('log-mail')) {
+    const { MailModule } = await import('@breadstone/archipel-platform-mailing');
+    const { LogDeliveryStrategy } = await import('@breadstone/archipel-platform-mailing/delivering/log');
+    return MailModule.register({ deliveryStrategy: LogDeliveryStrategy });
+  }
+
+  return null;
+}
+```
+
+Then compose cleanly in main:
+
+```typescript
+const builder = await PlatformApplicationBuilder.createWithComposition(
+  async (context) => {
+    const imports: CompositionImport[] = [AppModule];
+
+    const mailModule = await composeMailProvider(context);
+    if (mailModule) imports.push(mailModule);
+
+    const paymentModule = await composePaymentProvider(context);
+    if (paymentModule) imports.push(paymentModule);
+
+    return imports;
+  },
+  { compositionModule: AppCompositionModule }
+);
+```
+
+---
+
+## Testing Composition
+
+### Unit Testing a Resolver
+
+```typescript
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { ConfigService } from '@breadstone/archipel-platform-configuration';
+import { AppCompositionResolver } from './AppCompositionResolver';
+
+describe('AppCompositionResolver', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('uses SMTP in production regardless of driver setting', () => {
+    const configService = {
+      get: vi.fn((key: string) => {
+        if (key === 'MAIL_DRIVER') return 'log';
+        if (key === 'NODE_ENV') return 'production';
+        return undefined;
+      }),
+      tryGet: vi.fn((key: string, fallback: string) => {
+        if (key === 'MAIL_DRIVER') return 'log';
+        if (key === 'NODE_ENV') return 'production';
+        return fallback;
+      }),
+    } as unknown as ConfigService;
+
+    const resolver = new AppCompositionResolver(configService);
+
+    expect(resolver.shouldImportProvider('smtp-mail')).toBe(true);
+    expect(resolver.shouldImportProvider('log-mail')).toBe(false);
+  });
+});
+```
+
+### Integration Testing with Real Context
+
+```typescript
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createCompositionContext } from '@breadstone/archipel-platform-bootstrap/composition';
+import { AppCompositionModule, AppCompositionResolver } from './composition';
+
+describe('Composition Integration', () => {
+  let originalEnv: Record<string, string | undefined>;
+
+  beforeEach(() => {
+    originalEnv = {
+      MAIL_DRIVER: process.env['MAIL_DRIVER'],
+      NODE_ENV: process.env['NODE_ENV'],
+    };
+  });
+
+  afterEach(() => {
+    for (const [key, value] of Object.entries(originalEnv)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+
+  it('resolves correct mail provider for production', async () => {
+    process.env['NODE_ENV'] = 'production';
+    process.env['MAIL_DRIVER'] = 'log';
+
+    const context = await createCompositionContext({
+      module: AppCompositionModule,
+    });
+
+    try {
+      const resolver = context.getService(AppCompositionResolver);
+      expect(resolver.shouldImportProvider('smtp-mail')).toBe(true);
+    } finally {
+      await context.close();
+    }
+  });
+});
+```
+
+---
+
+## API Reference
+
+### createCompositionContext
+
+```typescript
+function createCompositionContext(
+  options?: ICreateCompositionContextOptions
+): Promise<ICompositionContext>;
+```
+
+| Option | Type | Default | Description |
+| ------ | ---- | ------- | ----------- |
+| `module` | `Type<unknown>` | `CompositionModule` | Custom composition module |
+| `enableLogging` | `boolean` | `false` | Enable NestJS logger output |
+
+### PlatformApplicationBuilder.createWithComposition
+
+```typescript
+static async createWithComposition<TApp extends INestApplication>(
+  composer: (context: ICompositionContext) => Promise<CompositionImport[]> | CompositionImport[],
+  options?: ICreateWithCompositionOptions<TApp>
+): Promise<PlatformApplicationBuilder<TApp>>;
+```
+
+| Option | Type | Default | Description |
+| ------ | ---- | ------- | ----------- |
+| `compositionModule` | `Type<unknown>` | `CompositionModule` | Custom composition module |
+| `enableCompositionLogging` | `boolean` | `false` | Enable logging during composition |
+| `nestOptions` | `NestApplicationOptions` | `undefined` | Options for `NestFactory.create()` |
+| `platformOptions` | `IPlatformApplicationOptions` | `undefined` | Options for the builder |
+| `appFactory` | `(module: DynamicModule) => Promise<TApp>` | `undefined` | Custom app factory |
+
+---
+
+## Best Practices
+
+1. **Keep composition modules minimal** — Only configuration and resolver services. No database, queues, or heavy infrastructure.
+
+2. **Use dynamic imports** — Import provider modules only when needed to reduce bundle size and startup time.
+
+3. **Encapsulate decisions in resolvers** — Don't scatter `process.env` checks. Centralize in a `CompositionResolver`.
+
+4. **Test resolvers in isolation** — Unit test the decision logic separately from NestJS bootstrap.
+
+5. **Close the context** — Always call `context.close()` when using `createCompositionContext()` directly.
+
+6. **Prefer `tryGetConfigValue` over `getConfigValue`** — Provide sensible defaults for optional configuration.
+
+---
+
+## See Also
+
+- [Application Bootstrap](./application-bootstrap) — Standard bootstrap pipeline without composition
+- [Configuration Management](./configuration) — Typed configuration keys and strategies
+- [Implementing Ports](./implementing-ports) — Port/adapter pattern for swappable implementations

package/data/guides/database-setup.md

@@ -48,19 +48,19 @@ npx prisma init
 
 `platform-database` ships its own config keys and a ready-made entries array. Set the relevant variables in your environment:
 
-```env
+```dotenv
 DATABASE_URL=postgresql://user:password@localhost:5432/mydb
 ```
 
 For Prisma Accelerate (managed connection pooling), add the Accelerate URL from the Prisma Console:
 
-```env
+```dotenv
 DB_ACCELERATE_URL=prisma://accelerate.prisma-data.net/?api_key=your-accelerate-api-key
 ```
 
 Optional environment variables for Prisma Optimize (query analysis dashboard):
 
-```env
+```dotenv
 DB_OPTIMIZE=true
 DB_OPTIMIZE_API_KEY=your-optimize-api-key
 ```
@@ -120,7 +120,7 @@ Accelerate provides connection pooling, global caching, and query optimization
 
 Set `DB_ACCELERATE_URL` in your environment. The module reads it automatically via `ConfigService` — no code changes needed:
 
-```env
+```dotenv
 DB_ACCELERATE_URL=prisma://accelerate.prisma-data.net/?api_key=your-accelerate-api-key
 ```
 

package/data/guides/email-delivery.md

@@ -96,7 +96,7 @@ This ensures that importing the core package does **not** pull in provider-speci
 
 ### Core Variables
 
-```env
+```dotenv
 MAIL_TEMPLATE_ENGINE_FORMAT=html
 MAIL_SENDER_EMAIL=noreply@yourapp.com
 ```
@@ -109,7 +109,7 @@ The delivery strategy and template-fetch strategy are no longer configured via e
 
 #### SMTP
 
-```env
+```dotenv
 MAIL_SMTP_HOST=smtp.example.com
 MAIL_SMTP_PORT=587
 MAIL_SMTP_USER=user@example.com
@@ -119,25 +119,25 @@ MAIL_SMTP_SECURE=true
 
 #### Resend
 
-```env
+```dotenv
 MAIL_RESEND_API_KEY=re_...
 ```
 
 #### Postmark
 
-```env
+```dotenv
 MAIL_POSTMARK_API_KEY=...
 ```
 
 #### SendGrid
 
-```env
+```dotenv
 MAIL_SENDGRID_API_KEY=SG...
 ```
 
 #### Mailgun
 
-```env
+```dotenv
 MAIL_MAILGUN_API_KEY=key-...
 MAIL_MAILGUN_DOMAIN=mg.yourapp.com
 ```

package/data/guides/index.md

@@ -14,6 +14,7 @@ Practical guides for working with Archipel packages in your NestJS application.
 | [Getting Started](./getting-started)                      | Install packages, register your first module, implement ports, and run the app.                               |
 | [Configuration Management](./configuration)               | Type-safe config keys, strategy-based resolution, central registry, and validation.                           |
 | [Application Bootstrap](./application-bootstrap)           | Compose NestJS startup with platform-bootstrap, Express middleware, security, sessions, and OpenAPI.          |
+| [Composition Context](./composition-context)              | Stage-aware, configuration-driven module composition without direct process.env access.                       |
 | [Implementing Ports](./implementing-ports)                | How the port/adapter pattern works, how to write adapters, and how to test them.                              |
 | [Controller Best Practices](./controller-best-practices)  | Structure, annotate, and implement controllers — regions, DI, ResponseReturn, guards, and the @Api decorator. |
 | [Request & Response DTOs](./request-response-dtos)        | DTO naming conventions, validation decorators, cross-field validation, and class-transformer integration.     |

package/data/guides/openapi-and-feature-discovery.md

@@ -24,7 +24,7 @@ yarn add @breadstone/archipel-platform-openapi
 
 All four variables are **required**:
 
-```env
+```dotenv
 APP_VERSION=1.0.0
 SWAGGER_CONTACT_NAME=Your Team
 SWAGGER_CONTACT_URL=https://yourcompany.com

package/data/guides/queue-infrastructure.md

@@ -40,7 +40,7 @@ yarn add @vercel/queue
 
 ### Core Variables
 
-```env
+```dotenv
 QUEUE_MAX_JOBS=10000
 ```
 
@@ -48,7 +48,7 @@ QUEUE_MAX_JOBS=10000
 
 ### BullMQ Variables
 
-```env
+```dotenv
 BULLMQ_REDIS_URL=redis://localhost:6379
 BULLMQ_PREFIX=myapp:
 ```
@@ -57,7 +57,7 @@ BULLMQ_PREFIX=myapp:
 
 ### Azure Service Bus Variables
 
-```env
+```dotenv
 AZURE_CONNECTION_STRING=Endpoint=sb://my-namespace.servicebus.windows.net/;SharedAccessKeyName=...;SharedAccessKey=...
 AZURE_RECEIVE_WAIT_MS=5000
 ```
@@ -66,7 +66,7 @@ AZURE_RECEIVE_WAIT_MS=5000
 
 ### Vercel Queues Variables
 
-```env
+```dotenv
 VERCEL_QUEUE_REGION=iad1
 VERCEL_QUEUE_CONSUMER_GROUP=my-consumer
 VERCEL_QUEUE_TOKEN=

package/data/guides/telemetry-and-observability.md

@@ -43,7 +43,7 @@ When `enabled` is `false`, the module provides a no-op facade (`NoopTelemetryFac
 
 ## Configuration
 
-```env
+```dotenv
 TELEMETRY_ENABLED=true
 TELEMETRY_SERVICE_NAME=my-api
 TELEMETRY_EXPORTER_ENDPOINT=https://otel-collector.example.com:4318