@tumbaland/backend-core 1.43.0 → 1.45.0

package/src/groups/membership.ts

@@ -1,133 +0,0 @@
-import logger from '../logging/logger';
-import { internalGroupUrl } from './client';
-
-/**
- * Which groups a person belongs to, asked of group-service.
- *
- * This used to travel in the session token's `groups` claim, which made it only
- * as fresh as the token: a new member could not see the group until their next
- * renewal, and a removed one kept access until theirs, which is why membership
- * changes used to sign people out. Asked here instead, with a short cache, a
- * change reaches every service within CACHE_TTL_MS.
- *
- * Every request pays for this only once per person per service per cache
- * window; concurrent callers share one request.
- */
-const CACHE_TTL_MS = 30_000;
-
-/** Bounded so a service under enumeration can't grow the cache without limit. */
-const MAX_CACHE_ENTRIES = 5_000;
-
-const REQUEST_TIMEOUT_MS = 3_000;
-
-interface CacheEntry {
-  groups: string[];
-  expiresAt: number;
-}
-
-const cache = new Map<string, CacheEntry>();
-const inFlight = new Map<string, Promise<string[] | null>>();
-
-function putInCache(email: string, groups: string[]): void {
-  if (!cache.has(email) && cache.size >= MAX_CACHE_ENTRIES) {
-    // Map iterates in insertion order, so the first key is the oldest write.
-    const oldest = cache.keys().next();
-    if (!oldest.done) cache.delete(oldest.value);
-  }
-  cache.set(email, { groups, expiresAt: Date.now() + CACHE_TTL_MS });
-}
-
-async function fetchUserGroupIds(email: string): Promise<string[] | null> {
-  const baseUrl = internalGroupUrl();
-  const token = process.env.INTERNAL_SERVICE_TOKEN;
-
-  if (!baseUrl || !token) {
-    logger.error('Group membership lookup not configured', {
-      hasGroupApiUrl: Boolean(baseUrl),
-      hasInternalToken: Boolean(token)
-    });
-    return null;
-  }
-
-  try {
-    const response = await fetch(`${baseUrl}/api/groups/mine/ids?userEmail=${encodeURIComponent(email)}`, {
-      method: 'GET',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-internal-token': token,
-        'x-service-id': process.env.SERVICE_NAME || 'unknown-service'
-      },
-      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
-    });
-
-    if (!response.ok) {
-      logger.error('Group membership lookup failed', { email, status: response.status });
-      return null;
-    }
-
-    const body = (await response.json()) as { success?: boolean; data?: unknown };
-    if (!body.success || !Array.isArray(body.data)) {
-      logger.error('Group membership lookup returned no list', { email });
-      return null;
-    }
-    return body.data.filter((id): id is string => typeof id === 'string');
-  } catch (error) {
-    logger.error('Group membership lookup unreachable', { email, error: (error as Error)?.message });
-    return null;
-  }
-}
-
-/**
- * The ids of the groups `email` belongs to right now.
- *
- * When group-service cannot be asked, the last answer is used even if it has
- * expired, and failing that no groups at all: a person keeps their own data
- * through an outage and loses group data until it ends, rather than being
- * granted a group on a guess.
- */
-export async function getUserGroupIds(email: string): Promise<string[]> {
-  const key = email.toLowerCase();
-  const entry = cache.get(key);
-  if (entry && entry.expiresAt > Date.now()) return entry.groups;
-
-  let pending = inFlight.get(key);
-  if (!pending) {
-    pending = fetchUserGroupIds(key).finally(() => inFlight.delete(key));
-    inFlight.set(key, pending);
-  }
-
-  const groups = await pending;
-  if (groups) {
-    putInCache(key, groups);
-    return groups;
-  }
-  if (entry) {
-    logger.warn('Using the last known group membership while group-service is unreachable', { email: key });
-    return entry.groups;
-  }
-  return [];
-}
-
-/** For tests. */
-export function clearMembershipCache(): void {
-  cache.clear();
-  inFlight.clear();
-}
-
-type MembershipLookup = (user: { email: string; groups?: string[] }) => Promise<string[]>;
-
-const lookUpMembership: MembershipLookup = (user) => getUserGroupIds(user.email);
-let membershipLookup: MembershipLookup = lookUpMembership;
-
-/** The groups the auth middlewares put on `req.userGroups`. */
-export const currentGroupsOf = (user: { email: string; groups?: string[] }): Promise<string[]> =>
-  membershipLookup(user);
-
-/**
- * Replaces the lookup, for tests only; pass nothing to restore the real one.
- * Service suites reach it through `@tumbaland/backend-core/testing`, which makes
- * a test token's own `groups` claim the membership, so they need no group-service.
- */
-export function overrideMembershipLookupForTests(lookup?: MembershipLookup): void {
-  membershipLookup = lookup ?? lookUpMembership;
-}

package/src/groups/subject.test.ts

@@ -1,85 +0,0 @@
-jest.mock('../logging/logger', () => ({
-  __esModule: true,
-  default: { error: jest.fn(), warn: jest.fn(), info: jest.fn(), debug: jest.fn(), http: jest.fn() }
-}));
-
-import { Request } from 'express';
-import logger from '../logging/logger';
-import { clearGroupOwnerCache } from './client';
-import { groupOwnerSubject } from './subject';
-
-const ORIGINAL_ENV = process.env;
-const ORIGINAL_FETCH = global.fetch;
-
-function ownerResponse(ownerEmail = 'owner@example.com'): Response {
-  return {
-    ok: true,
-    status: 200,
-    json: async () => ({ success: true, groupId: 'group-1', ownerEmail, memberCount: 2, deleted: false })
-  } as Response;
-}
-
-const request = (overrides: Partial<Request> = {}) =>
-  ({ user: { id: '1', email: 'member@example.com', name: 'Member' }, originalUrl: '/api/photos', ...overrides }) as Request;
-
-beforeEach(() => {
-  process.env = {
-    ...ORIGINAL_ENV,
-    GROUP_API_URL: 'http://group-service:5006',
-    INTERNAL_SERVICE_TOKEN: 'test-internal-token'
-  };
-  clearGroupOwnerCache();
-  global.fetch = jest.fn();
-  (logger.error as jest.Mock).mockClear();
-});
-
-afterAll(() => {
-  process.env = ORIGINAL_ENV;
-  global.fetch = ORIGINAL_FETCH;
-});
-
-describe('groupOwnerSubject', () => {
-  it('bills a group resource to the group owner, not the uploader', async () => {
-    (global.fetch as jest.Mock).mockResolvedValue(ownerResponse());
-
-    const subject = groupOwnerSubject(() => 'group-1');
-
-    expect(await subject(request())).toBe('owner@example.com');
-  });
-
-  it('bills a personal resource to the caller and never asks group-service', async () => {
-    const subject = groupOwnerSubject(() => undefined);
-
-    expect(await subject(request())).toBe('member@example.com');
-    expect(global.fetch).not.toHaveBeenCalled();
-  });
-
-  it('accepts an async group-id resolver', async () => {
-    (global.fetch as jest.Mock).mockResolvedValue(ownerResponse());
-
-    const subject = groupOwnerSubject(async () => 'group-1');
-
-    expect(await subject(request())).toBe('owner@example.com');
-  });
-
-  it('falls back to the caller and logs when the owner cannot be resolved', async () => {
-    (global.fetch as jest.Mock).mockRejectedValue(new Error('ECONNREFUSED'));
-
-    const subject = groupOwnerSubject(() => 'group-1');
-
-    // Billing the caller checks the write against their own — typically
-    // smaller — allowance rather than refusing it outright, matching how the
-    // entitlement client degrades for the same class of outage.
-    expect(await subject(request())).toBe('member@example.com');
-    expect(logger.error).toHaveBeenCalledWith(
-      'Group owner unresolved; billing usage to the caller instead',
-      expect.objectContaining({ groupId: 'group-1', caller: 'member@example.com' })
-    );
-  });
-
-  it('returns undefined when there is no caller and no resolvable group, so the middleware 401s', async () => {
-    const subject = groupOwnerSubject(() => undefined);
-
-    expect(await subject(request({ user: undefined }))).toBeUndefined();
-  });
-});

package/src/groups/subject.ts

@@ -1,50 +0,0 @@
-import { Request } from 'express';
-import logger from '../logging/logger';
-import { SubjectResolver } from '../entitlements/middleware';
-import { getGroupOwner } from './client';
-
-export type GroupIdResolver = (req: Request) => string | undefined | Promise<string | undefined>;
-
-/**
- * Builds the `subject` resolver that `requireQuota` / `requireEntitlement`
- * already accept, for the meters whose resource can live in a group.
- *
- * ```ts
- * requireQuota('storageBytes', {
- *   subject: groupOwnerSubject(req => req.body.groupId),
- *   amount: req => req.body.sizeBytes
- * })
- * ```
- *
- * Personal rows keep billing to the caller; group rows bill to the group's
- * owner, because Family sells *pooled* storage and seats and the uploader's own
- * free tier is not the pool.
- *
- * **When the owner cannot be resolved, it bills the caller and says so.** The
- * alternative — refusing the write — is harsher than what the entitlement
- * client itself does for the same class of outage (it degrades to free limits
- * rather than denying), and the error direction here is bounded in the shape
- * that matters: the common case is a member on a cheap personal plan uploading
- * into a group owned by someone on Family, so falling back to the caller checks
- * against the *smaller* allowance. It can over-grant when the caller happens to
- * hold the richer plan, which is why it logs at `error` — a run of these means
- * group-service is down, not that a limit is wrong.
- */
-export function groupOwnerSubject(resolveGroupId: GroupIdResolver): SubjectResolver {
-  return async (req: Request) => {
-    const caller = req.user?.email;
-    const groupId = await resolveGroupId(req);
-    if (!groupId) return caller;
-
-    const owner = await getGroupOwner(String(groupId));
-    if (owner) return owner.ownerEmail;
-
-    logger.error('Group owner unresolved; billing usage to the caller instead', {
-      event: 'entitlement.subject_fallback',
-      groupId: String(groupId),
-      caller,
-      route: req.originalUrl
-    });
-    return caller;
-  };
-}

package/src/health/createHealthCheck.test.ts

@@ -1,89 +0,0 @@
-import { Request, Response } from 'express';
-import mongoose from 'mongoose';
-import { createHealthCheck } from './createHealthCheck';
-
-function mockRes(): Response {
-  const res: Partial<Response> = {};
-  res.status = jest.fn().mockReturnValue(res);
-  res.json = jest.fn().mockReturnValue(res);
-  return res as Response;
-}
-
-describe('createHealthCheck', () => {
-  const config = { service: 'demo-service', description: 'Demo service' };
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('responds 200 with dependencies.mongodb "connected" when Mongo is up', async () => {
-    jest.spyOn(mongoose, 'connection', 'get').mockReturnValue({ readyState: 1 } as never);
-    const res = mockRes();
-
-    await createHealthCheck(config)({} as Request, res);
-
-    expect(res.status).toHaveBeenCalledWith(200);
-    expect(res.json).toHaveBeenCalledWith(
-      expect.objectContaining({
-        status: 'ok',
-        service: 'demo-service',
-        type: 'backend',
-        version: '1.0.0',
-        description: 'Demo service',
-        dependencies: { mongodb: 'connected' }
-      })
-    );
-  });
-
-  it('responds 503 with dependencies.mongodb "disconnected" when Mongo is down', async () => {
-    jest.spyOn(mongoose, 'connection', 'get').mockReturnValue({ readyState: 0 } as never);
-    const res = mockRes();
-
-    await createHealthCheck(config)({} as Request, res);
-
-    expect(res.status).toHaveBeenCalledWith(503);
-    expect(res.json).toHaveBeenCalledWith(
-      expect.objectContaining({ status: 'error', dependencies: { mongodb: 'disconnected' } })
-    );
-  });
-
-  it('honors an explicit version override', async () => {
-    jest.spyOn(mongoose, 'connection', 'get').mockReturnValue({ readyState: 1 } as never);
-    const res = mockRes();
-
-    await createHealthCheck({ ...config, version: '2.3.4' })({} as Request, res);
-
-    expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ version: '2.3.4' }));
-  });
-
-  it('responds 503 with a generic error body when reading connection state throws', async () => {
-    jest.spyOn(mongoose, 'connection', 'get').mockImplementation(() => {
-      throw new Error('boom');
-    });
-    const res = mockRes();
-
-    await createHealthCheck(config)({} as Request, res);
-
-    expect(res.status).toHaveBeenCalledWith(503);
-    expect(res.json).toHaveBeenCalledWith(
-      expect.objectContaining({ status: 'error', service: 'demo-service', error: 'Health check failed' })
-    );
-  });
-
-  describe('checkDatabase: false (DB-less services)', () => {
-    it('always responds 200 ok without touching Mongo or emitting dependencies', async () => {
-      const connectionSpy = jest.spyOn(mongoose, 'connection', 'get');
-      const res = mockRes();
-
-      await createHealthCheck({ ...config, checkDatabase: false })({} as Request, res);
-
-      expect(connectionSpy).not.toHaveBeenCalled();
-      expect(res.status).toHaveBeenCalledWith(200);
-      const body = (res.json as jest.Mock).mock.calls[0][0];
-      expect(body).toEqual(
-        expect.objectContaining({ status: 'ok', service: 'demo-service', type: 'backend', description: 'Demo service' })
-      );
-      expect(body).not.toHaveProperty('dependencies');
-    });
-  });
-});

package/src/health/createHealthCheck.ts

@@ -1,67 +0,0 @@
-import { Request, Response } from 'express';
-import mongoose from 'mongoose';
-
-export interface HealthCheckConfig {
-  /** Service name reported in the body, e.g. `auth-service`. */
-  service: string;
-  /** Human-readable service description. */
-  description: string;
-  /** Reported version. Defaults to `1.0.0`. */
-  version?: string;
-  /**
-   * Whether readiness depends on the MongoDB connection. Defaults to `true`:
-   * the response reports `dependencies.mongodb` and returns 503 while
-   * disconnected. Set `false` for services with no database (e.g.
-   * public-service), which then always report `ok` with no `dependencies`.
-   */
-  checkDatabase?: boolean;
-}
-
-/**
- * The single, unified `/health` readiness handler for every backend service.
- *
- * Response contract (identical across services):
- *   { status, service, type: 'backend', timestamp, version, description }
- * plus, when `checkDatabase` is `true` (the default), a
- * `dependencies.mongodb` field and a 503 while the connection is down. A
- * DB-less service (`checkDatabase: false`) omits `dependencies` and always
- * reports `ok`. On an unexpected failure the handler returns 503 with a
- * generic `error: 'Health check failed'` body.
- *
- * `/health/live` (liveness, no dependency checks) is mounted separately by
- * `createBaseApp`.
- */
-export const createHealthCheck = ({
-  service,
-  description,
-  version = '1.0.0',
-  checkDatabase = true
-}: HealthCheckConfig) => {
-  return async (_req: Request, res: Response): Promise<void> => {
-    const timestamp = new Date().toISOString();
-    const base = { service, type: 'backend', timestamp, version, description };
-
-    if (!checkDatabase) {
-      res.status(200).json({ status: 'ok', ...base });
-      return;
-    }
-
-    try {
-      const isMongoHealthy = mongoose.connection.readyState === 1; // 1 = connected
-
-      res.status(isMongoHealthy ? 200 : 503).json({
-        status: isMongoHealthy ? 'ok' : 'error',
-        ...base,
-        dependencies: {
-          mongodb: isMongoHealthy ? 'connected' : 'disconnected'
-        }
-      });
-    } catch {
-      res.status(503).json({
-        status: 'error',
-        ...base,
-        error: 'Health check failed'
-      });
-    }
-  };
-};

package/src/health/healthController.test.ts

@@ -1,113 +0,0 @@
-import { Request, Response } from 'express';
-import mongoose from 'mongoose';
-import { healthCheck, healthLive, metricsHandler } from './healthController';
-
-function mockRes(): Response {
-  const res: Partial<Response> = {};
-  res.status = jest.fn().mockReturnValue(res);
-  res.json = jest.fn().mockReturnValue(res);
-  return res as Response;
-}
-
-describe('healthLive', () => {
-  it('always responds 200 ok, independent of any dependency state', () => {
-    const res = mockRes();
-    healthLive({} as Request, res);
-
-    expect(res.status).toHaveBeenCalledWith(200);
-    expect(res.json).toHaveBeenCalledWith({ status: 'ok' });
-  });
-});
-
-describe('healthCheck', () => {
-  const ORIGINAL_ENV = process.env;
-
-  beforeEach(() => {
-    process.env = { ...ORIGINAL_ENV };
-  });
-
-  afterAll(() => {
-    process.env = ORIGINAL_ENV;
-  });
-
-  it('responds 200 with dependencies.mongodb "connected" when Mongo readyState is 1', async () => {
-    jest.spyOn(mongoose, 'connection', 'get').mockReturnValue({ readyState: 1 } as any);
-    process.env.SERVICE_NAME = 'album-service';
-    const res = mockRes();
-
-    await healthCheck({} as Request, res);
-
-    expect(res.status).toHaveBeenCalledWith(200);
-    expect(res.json).toHaveBeenCalledWith(
-      expect.objectContaining({
-        status: 'ok',
-        service: 'album-service',
-        dependencies: { mongodb: 'connected' }
-      })
-    );
-  });
-
-  it('responds 503 with dependencies.mongodb "disconnected" when Mongo readyState is not 1', async () => {
-    jest.spyOn(mongoose, 'connection', 'get').mockReturnValue({ readyState: 0 } as any);
-    const res = mockRes();
-
-    await healthCheck({} as Request, res);
-
-    expect(res.status).toHaveBeenCalledWith(503);
-    expect(res.json).toHaveBeenCalledWith(
-      expect.objectContaining({ status: 'error', dependencies: { mongodb: 'disconnected' } })
-    );
-  });
-
-  it('falls back to default service/version/description when env vars are unset', async () => {
-    delete process.env.SERVICE_NAME;
-    delete process.env.npm_package_version;
-    delete process.env.SERVICE_DESCRIPTION;
-    jest.spyOn(mongoose, 'connection', 'get').mockReturnValue({ readyState: 1 } as any);
-    const res = mockRes();
-
-    await healthCheck({} as Request, res);
-
-    expect(res.json).toHaveBeenCalledWith(
-      expect.objectContaining({
-        service: 'unknown-service',
-        version: '1.0.0',
-        description: 'Backend service'
-      })
-    );
-  });
-
-  it('responds 503 with a generic error body when reading connection state throws', async () => {
-    jest.spyOn(mongoose, 'connection', 'get').mockImplementation(() => {
-      throw new Error('boom');
-    });
-    const res = mockRes();
-
-    await healthCheck({} as Request, res);
-
-    expect(res.status).toHaveBeenCalledWith(503);
-    expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ status: 'error', error: 'Health check failed' }));
-  });
-
-  it('falls back to default service/version/description in the error body when env vars are unset', async () => {
-    delete process.env.SERVICE_NAME;
-    delete process.env.npm_package_version;
-    delete process.env.SERVICE_DESCRIPTION;
-    jest.spyOn(mongoose, 'connection', 'get').mockImplementation(() => {
-      throw new Error('boom');
-    });
-    const res = mockRes();
-
-    await healthCheck({} as Request, res);
-
-    expect(res.json).toHaveBeenCalledWith(
-      expect.objectContaining({ service: 'unknown-service', version: '1.0.0', description: 'Backend service' })
-    );
-  });
-});
-
-describe('metricsHandler re-export', () => {
-  it('re-exports the same metricsHandler function from ../metrics', () => {
-    expect(typeof metricsHandler).toBe('function');
-  });
-});

package/src/health/healthController.ts

@@ -1,56 +0,0 @@
-import { Request, Response } from 'express';
-import mongoose from 'mongoose';
-import { metricsHandler } from '../metrics';
-
-/**
- * Health check endpoint with database connectivity
- * Returns comprehensive health status for monitoring
- */
-export const healthCheck = async (req: Request, res: Response) => {
-  try {
-    // Check MongoDB connection
-    const mongoState = mongoose.connection.readyState;
-    const isMongoHealthy = mongoState === 1; // 1 = connected
-
-    const healthResponse = {
-      status: isMongoHealthy ? 'ok' : 'error',
-      service: process.env.SERVICE_NAME || 'unknown-service',
-      type: 'backend',
-      timestamp: new Date().toISOString(),
-      version: process.env.npm_package_version || '1.0.0',
-      description: process.env.SERVICE_DESCRIPTION || 'Backend service',
-      dependencies: {
-        mongodb: isMongoHealthy ? 'connected' : 'disconnected'
-      }
-    };
-
-    res.status(isMongoHealthy ? 200 : 503).json(healthResponse);
-  } catch (error) {
-    res.status(503).json({
-      status: 'error',
-      service: process.env.SERVICE_NAME || 'unknown-service',
-      type: 'backend',
-      timestamp: new Date().toISOString(),
-      version: process.env.npm_package_version || '1.0.0',
-      description: process.env.SERVICE_DESCRIPTION || 'Backend service',
-      error: 'Health check failed'
-    });
-  }
-};
-
-/**
- * Liveness check: confirms the process is up and serving HTTP, without
- * touching MongoDB or any other dependency. Used by the Docker-level
- * HEALTHCHECK so a transient DB outage doesn't get reported as the
- * container itself being unhealthy — `/health` (above) is the DB-aware
- * readiness check for dashboards/monitoring.
- */
-export const healthLive = (req: Request, res: Response) => {
-  res.status(200).json({ status: 'ok' });
-};
-
-/**
- * Prometheus metrics endpoint
- * Exposes application metrics for monitoring
- */
-export { metricsHandler };

package/src/index.ts

@@ -1,88 +0,0 @@
-// @tumbaland/backend-core - Core shared functionality for Tumbaland backend services
-
-// App bootstrap
-export { createBaseApp } from './app/createBaseApp';
-export type { CreateBaseAppOptions } from './app/createBaseApp';
-export { registerShutdown } from './app/shutdown';
-export type { RegisterShutdownOptions } from './app/shutdown';
-
-// Logging
-export { default as logger } from './logging/logger';
-
-// Health checks
-export { healthCheck, healthLive, metricsHandler } from './health/healthController';
-export { createHealthCheck } from './health/createHealthCheck';
-export type { HealthCheckConfig } from './health/createHealthCheck';
-
-// Database
-export { connectDB, disconnectDB } from './database/connection';
-
-// Config
-export { requireEnv } from './config/env';
-
-// Errors
-export { HttpError, BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, ConflictError, TooManyRequestsError, PaymentRequiredError } from './errors/HttpError';
-export type { PaymentRequiredDetails } from './errors/HttpError';
-
-// Entitlements (plan limits, usage meters, enforcement)
-export * from './entitlements';
-
-// Group ownership (the quota subject for anything pooled)
-export * from './groups';
-
-// API keys (non-browser clients: MCP servers, scripts, agents)
-export * from './apiKeys';
-
-// OAuth 2.1 authorization server, for assistants connecting over MCP
-export * from './oauth';
-export * from './audit';
-
-// Middleware
-export { authenticateToken, optionalAuth } from './middleware/authMiddleware';
-export { USER_SESSIONS_COLLECTION, isCurrentSession, isLegacySessionlessToken } from './auth/session';
-export {
-  requireInternalServiceToken,
-  internalServiceTokenBypass,
-  allowUserOrInternalService,
-  verifyInternalToken,
-  INTERNAL_TOKEN_HEADER,
-  SERVICE_ID_HEADER
-} from './middleware/internalServiceAuth';
-export { createCorsMiddleware } from './middleware/corsMiddleware';
-export { errorHandler } from './middleware/errorHandler';
-export { requestLogger, requestLoggerWithMetrics, simpleRequestLogger } from './middleware/requestLogger';
-export { securityHeaders, createRateLimiter, standardRateLimiter, strictRateLimiter } from './middleware/security';
-export { validate } from './middleware/validate';
-
-// Types
-export type { UserPayload } from './types/auth';
-
-// Utils
-export { generateCorrelationId, correlationMiddleware } from './utils/correlation';
-export { createApiResponse, sendSuccess, sendError } from './utils/response';
-export type { ApiResponse } from './utils/response';
-export { buildAccessQuery, canAccessResource } from './utils/permissionUtils';
-
-// Metrics
-export {
-  metricsMiddleware,
-  httpRequestDuration,
-  httpRequestsTotal,
-  databaseQueryDuration,
-  databaseQueriesTotal,
-  businessMetrics,
-  register
-} from './metrics';
-
-// Tracing
-export {
-  initTracer,
-  getTracer,
-  startSpan,
-  tracingMiddleware,
-  createChildSpan,
-  logToSpan,
-  setSpanTag,
-  injectHeaders,
-  extractSpanContext
-} from './tracing';