Monitoring & Observability

const winston = require('winston');

const logger = winston.createLogger({
  format: winston.format.json(),
  transports: [new winston.transports.Console()]
});

app.post('/webhooks/smartcar', async (req, res) => {
  const payload = req.body;
  const { eventId, eventType, vehicleId } = payload;
  
  // Log receipt
  logger.info('webhook.received', {
    eventId,
    eventType,
    vehicleId
  });
  
  // Verify signature
  const isValid = verifySignature(req.rawBody, req.headers['sc-signature']);
  logger.info('signature.verified', { eventId, valid: isValid });
  
  if (!isValid) {
    logger.warn('signature.failed', {
      eventId,
      sourceIp: req.ip
    });
    return res.status(401).json({ error: 'Invalid signature' });
  }
  
  // Queue and return
  await queue.add(payload);
  res.status(200).json({ status: 'received' });
});

async function processWebhook(payload) {
  const { eventId } = payload;
  const startTime = Date.now();
  
  logger.info('processing.started', { eventId });
  
  try {
    await updateVehicleData(payload);
    logger.info('processing.completed', {
      eventId,
      durationMs: Date.now() - startTime
    });
  } catch (error) {
    logger.error('processing.failed', {
      eventId,
      error: error.message,
      stack: error.stack
    });
    throw error;
  }
}

import structlog

logger = structlog.get_logger()

@app.post("/webhooks/smartcar")
def webhook_handler():
    payload = request.get_json()
    event_id = payload.get("eventId")
    
    # Log receipt
    logger.info("webhook.received",
        event_id=event_id,
        event_type=payload.get("eventType"),
        vehicle_id=payload.get("vehicleId")
    )
    
    # Verify signature
    is_valid = verify_signature(request.data, request.headers.get('SC-Signature'))
    logger.info("signature.verified",
        event_id=event_id,
        valid=is_valid
    )
    
    if not is_valid:
        logger.warning("signature.failed",
            event_id=event_id,
            source_ip=request.remote_addr
        )
        return {"error": "Invalid signature"}, 401
    
    # Queue and return
    queue.enqueue(process_webhook, payload)
    return {"status": "received"}, 200

def process_webhook(payload):
    event_id = payload.get("eventId")
    
    logger.info("processing.started", event_id=event_id)
    
    try:
        update_vehicle_data(payload)
        logger.info("processing.completed", 
            event_id=event_id,
            duration_ms=duration
        )
    except Exception as e:
        logger.error("processing.failed",
            event_id=event_id,
            error=str(e),
            exc_info=True
        )
        raise