// BEFORE: Original function
function processOrder(order) {
  // Implementation
}

// AFTER: With telemetry
// Step 1: Create private implementation
function _processOrder(order) {
  // Same implementation as before
}

// Step 2: Create public wrapper with telemetry
function processOrder(order) {
  const executionId = generateExecutionId('order');
  
  return telemetry.wrapWithSpan(
    'processOrder', 
    { 'order.id': order.id, 'execution.id': executionId }, 
    () => _processOrder(order)
  );
}

// Parent function
function _processOrder(order) {
  // Validate order first
  _validateOrder(order);
  
  // Process payment
  const payment = _processPayment(order.payment);
  
  // Create shipment
  const shipment = _createShipment(order.items, order.address);
  
  return { orderId: order.id, status: 'completed' };
}

// Child function with its own span
function _validateOrder(order) {
  return telemetry.wrapWithSpan(
    '_validateOrder',
    { 'order.id': order.id },
    () => {
      // Validation logic
      return isValid;
    }
  );
}

function processOrder(order) {
  return telemetry.wrapWithSpan(
    'processOrder', 
    { attributes }, 
    async (span) => {
      try {
        const result = await _processOrder(order);
        return result;
      } catch (error) {
        // Record error in span
        span.setStatus({
          code: SpanStatusCode.ERROR,
          message: error.message
        });
        span.recordException(error);
        throw error;
      }
    }
  );
}

// PUBLIC API
const initBackupJob = telemetry.wrapWithSpan(_initBackupJob, 'initBackupJob', {
  'job.name': 'dataBackupJob',
  'job.type': 'cron',
});

function performBackup(executionId) {
  const execId = executionId || generateExecutionId('backup');
  return telemetry.wrapWithSpan(() => _performBackup(execId), `performBackup.${execId}`, {
    'backup.type': 'scheduled',
    'backup.execution_id': execId,
  })();
}

// IMPLEMENTATION DETAILS
function _initBackupJob() {
  if (!CONFIG.enabled) {
    loggingService.logInfo('Data backup job is disabled');
    return false;
  }

  loggingService.logInfo(`Scheduling data backup job with schedule: ${CONFIG.schedule}`);

  const job = cron.schedule(CONFIG.schedule, () => {
    const executionId = generateExecutionId('backup');
    const executionTracer = telemetry.getTracer(`dataBackupJob.${executionId}`);

    executionTracer.startActiveSpan('backupJob.execution', span => {
      try {
        span.setAttribute('backup.scheduled_time', new Date().toISOString());
        span.setAttribute('backup.cron_pattern', CONFIG.schedule);
        span.setAttribute('backup.execution_id', executionId);

        const result = performBackup(executionId);

        span.setAttribute('backup.success', result.success);
        span.end();
        return result;
      } catch (error) {
        span.recordException(error);
        span.setStatus({ code: SpanStatusCode.ERROR });
        span.end();
        throw error;
      }
    });
  });

  return job;
}

// PUBLIC API
const sendNotification = telemetry.wrapWithSpan(
  _sendNotification,
  'notificationService.sendNotification',
  { 'notification.operation': 'send' }
);

// IMPLEMENTATION DETAILS
function _sendNotification(userId, message, channel = 'email') {
  try {
    const notificationId = uuidv4();
    const content = await _prepareNotificationContent(userId, message, channel);
    
    // Record notification
    notifications[notificationId] = { /*...*/ };
    
    // Deliver through chosen channel
    const deliveryResult = await _deliverNotification(userId, notifications[notificationId], channel);
    
    notifications[notificationId].status = 'sent';
    return notifications[notificationId];
  } catch (error) {
    loggingService.logError(`Failed to send notification: ${error.message}`);
    throw error;
  }
}

// Nested functions with their own spans
function _prepareNotificationContent(userId, message, channel) {/*...*/}
function _getUserNotificationPreferences(userId) {/*...*/}
function _getUserDeviceInfo(userId) {/*...*/}
function _deliverNotification(userId, notification, channel) {/*...*/}

// Create a singleton Telemetry class
class Telemetry {
  constructor(serviceName, serviceVersion, enabled = true) {
    this.serviceName = serviceName || process.env.SERVICE_NAME || 'default-service';
    this.serviceVersion = serviceVersion || process.env.SERVICE_VERSION || '1.0.0';
    this.enabled = enabled;
    this.initialized = false;
  }
  
  // Enable/disable telemetry at runtime
  setEnabled(enabled) {
    this.enabled = !!enabled;
    return this;
  }
  
  // Core tracing method - wrap any function with tracing
  wrapWithSpan(fn, name, attributes = {}) {
    // If telemetry is disabled, just return the original function
    if (!this.enabled) {
      return (...args) => fn(...args);
    }
    
    return (...args) => {
      const tracer = this.getTracer(name.split('.')[0] || 'default');
      return tracer.startActiveSpan(name, { attributes }, span => {
        try {
          const result = fn(...args);
          
          // Handle promises
          if (result && typeof result.then === 'function') {
            return result
              .then(value => {
                span.end();
                return value;
              })
              .catch(error => {
                span.setStatus({ code: SpanStatusCode.ERROR });
                span.recordException(error);
                span.end();
                throw error;
              });
          }
          
          span.end();
          return result;
        } catch (error) {
          span.setStatus({ code: SpanStatusCode.ERROR });
          span.recordException(error);
          span.end();
          throw error;
        }
      });
    };
  }
  
  // Additional methods...
}

// Create singleton instance
const telemetry = new Telemetry(
  process.env.SERVICE_NAME,
  process.env.SERVICE_VERSION,
  process.env.TELEMETRY_ENABLED !== 'false'
);

// Export the singleton
module.exports = telemetry;

// Disable telemetry at runtime
telemetry.setEnabled(false);

// Check if telemetry is enabled
console.log(`Telemetry enabled: ${telemetry.isEnabled()}`);