Legacy Compatibility API

/**
 * Initializes the default client with connection string or instrumentation key
 * @param setupString - Connection string or instrumentation key (optional, reads from environment if not provided)
 * @returns Configuration class for method chaining
 */
function setup(setupString?: string): typeof Configuration;

/**
 * Starts automatic collection of telemetry
 * @returns Configuration class for method chaining
 */
function start(): typeof Configuration;

/**
 * Disposes the default client and all auto collectors
 * Allows reinitialization with different configuration
 */
function dispose(): void;

const appInsights = require("applicationinsights");

// Traditional setup with connection string
appInsights
  .setup("InstrumentationKey=12345678-1234-1234-1234-123456789abc;IngestionEndpoint=...")
  .start();

// Setup with environment variable
appInsights
  .setup() // Reads APPLICATIONINSIGHTS_CONNECTION_STRING
  .start();

// Dispose and reinitialize
appInsights.dispose();
appInsights
  .setup("new-connection-string")
  .start();

/**
 * The default client, initialized when setup was called
 * Use this for manual telemetry tracking with the default configuration
 */
let defaultClient: TelemetryClient;

const appInsights = require("applicationinsights");

// Initialize
appInsights.setup().start();

// Use default client for tracking
appInsights.defaultClient.trackEvent({
  name: "UserAction",
  properties: { action: "button-click" }
});

appInsights.defaultClient.trackTrace({
  message: "Application started",
  severity: appInsights.Contracts.SeverityLevel.Information
});

/**
 * All telemetry contract types and interfaces
 */
export const Contracts: {
  AvailabilityTelemetry: typeof AvailabilityTelemetry;
  TraceTelemetry: typeof TraceTelemetry;
  ExceptionTelemetry: typeof ExceptionTelemetry;
  EventTelemetry: typeof EventTelemetry;
  PageViewTelemetry: typeof PageViewTelemetry;
  RequestTelemetry: typeof RequestTelemetry;
  DependencyTelemetry: typeof DependencyTelemetry;
  MetricTelemetry: typeof MetricTelemetry;
  Telemetry: typeof Telemetry;
  TelemetryType: typeof TelemetryType;
  SeverityLevel: typeof SeverityLevel;
};

/**
 * Distributed tracing modes
 */
export const DistributedTracingModes: {
  AI: 0;
  AI_AND_W3C: 1;
};

/**
 * HTTP request interface for context
 */
export const HttpRequest: typeof HttpRequest;

const appInsights = require("applicationinsights");

// Use contract types
appInsights.defaultClient.trackTrace({
  message: "Debug information",
  severity: appInsights.Contracts.SeverityLevel.Verbose,
  properties: { component: "auth-service" }
});

appInsights.defaultClient.trackException({
  exception: new Error("Something went wrong"),
  severity: appInsights.Contracts.SeverityLevel.Error
});

// Check telemetry types
if (telemetryType === appInsights.Contracts.TelemetryType.Event) {
  // Handle event telemetry
}

/**
 * Traditional fluent configuration pattern
 */
interface FluentConfiguration {
  setup(setupString?: string): typeof Configuration;
  setAutoCollectRequests(value: boolean): typeof Configuration;
  setAutoCollectPerformance(value: boolean, collectExtendedMetrics?: any): typeof Configuration;
  setAutoCollectExceptions(value: boolean): typeof Configuration;
  setAutoCollectDependencies(value: boolean): typeof Configuration;
  setAutoCollectConsole(value: boolean, collectConsoleLog?: boolean): typeof Configuration;
  setAutoCollectPreAggregatedMetrics(value: boolean): typeof Configuration;
  setAutoCollectHeartbeat(value: boolean): typeof Configuration;
  setUseDiskRetryCaching(value: boolean, resendInterval?: number, maxBytesOnDisk?: number): typeof Configuration;
  setAutoDependencyCorrelation(value: boolean, useAsyncHooks?: boolean): typeof Configuration;
  setInternalLogging(enableDebugLogger?: boolean, enableWarningLogger?: boolean): typeof Configuration;
  setSendLiveMetrics(enable?: boolean): typeof Configuration;
  enableWebInstrumentation(value: boolean, webSnippetConnectionString?: string): typeof Configuration;
  start(): typeof Configuration;
}

const appInsights = require("applicationinsights");

// Traditional fluent configuration
appInsights
  .setup() // Connection string from environment
  .setAutoCollectRequests(true)
  .setAutoCollectPerformance(true, true)
  .setAutoCollectExceptions(true) 
  .setAutoCollectDependencies(true)
  .setAutoDependencyCorrelation(true)
  .setAutoCollectConsole(true, false)
  .setUseDiskRetryCaching(true)
  .setInternalLogging(false, true)
  .start();

/**
 * Supported environment variables:
 * - APPLICATIONINSIGHTS_CONNECTION_STRING: Primary connection string
 * - APPINSIGHTS_INSTRUMENTATIONKEY: Legacy instrumentation key (deprecated)
 */

# Environment variables
export APPLICATIONINSIGHTS_CONNECTION_STRING="InstrumentationKey=...;IngestionEndpoint=..."

# Or legacy (deprecated)
export APPINSIGHTS_INSTRUMENTATIONKEY="12345678-1234-1234-1234-123456789abc"

// Application code - no connection string needed
const appInsights = require("applicationinsights");

appInsights
  .setup() // Automatically reads environment variables
  .start();

// Application Insights 2.x
const appInsights = require("applicationinsights");
appInsights.setup().start();

// Application Insights 3.x (no changes needed)
const appInsights = require("applicationinsights");
appInsights.setup().start();

// Application Insights 2.x
appInsights.defaultClient.trackEvent({
  name: "UserLogin",
  properties: { userId: "123" }
});

// Application Insights 3.x (same API)
appInsights.defaultClient.trackEvent({
  name: "UserLogin", 
  properties: { userId: "123" }
});

// Application Insights 2.x
appInsights
  .setup()
  .setAutoCollectRequests(true)
  .setAutoCollectDependencies(true)
  .setAutoCollectExceptions(true)
  .start();

// Application Insights 3.x (same API)
appInsights
  .setup()
  .setAutoCollectRequests(true)
  .setAutoCollectDependencies(true)
  .setAutoCollectExceptions(true)
  .start();

/**
 * Deprecated methods that throw errors or log warnings:
 */

// Throws error - not implemented
client.track(telemetry: any, telemetryType: any): never;
client.clearTelemetryProcessors(): never;
client.setUseDiskRetryCaching(): never;

// Logs warning - no-op
client.trackNodeHttpRequestSync(telemetry: any): void;
client.trackNodeHttpRequest(telemetry: any): void;  
client.trackNodeHttpDependency(telemetry: any): void;
client.addTelemetryProcessor(processor: any): void;
client.setAutoPopulateAzureProperties(): void;
client.getAuthorizationHandler(config: any): void;
client.getStatsbeat(): any; // Returns null

const appInsights = require("applicationinsights");

// Traditional Application Insights 2.x style initialization
appInsights
  .setup() // Uses APPLICATIONINSIGHTS_CONNECTION_STRING environment variable
  .setAutoCollectRequests(true)
  .setAutoCollectPerformance(true, true)
  .setAutoCollectExceptions(true)
  .setAutoCollectDependencies(true)
  .setAutoCollectConsole(true, false)
  .setAutoCollectPreAggregatedMetrics(true)
  .setUseDiskRetryCaching(true, 30000, 50 * 1024 * 1024)
  .setAutoDependencyCorrelation(true)
  .setSendLiveMetrics(false)
  .start();

// Manual telemetry tracking
appInsights.defaultClient.trackEvent({
  name: "ApplicationStarted",
  properties: {
    version: process.env.npm_package_version,
    environment: process.env.NODE_ENV
  }
});

appInsights.defaultClient.trackTrace({
  message: "Application Insights initialized successfully",
  severity: appInsights.Contracts.SeverityLevel.Information
});

// Graceful shutdown
process.on('SIGTERM', () => {
  appInsights.dispose();
  process.exit(0);
});