""" Olist E-commerce Streaming Simulator (Kaggle Dataset Version) =============================================================== Reads static CSV files from Kaggle's Brazilian E-Commerce dataset and replays them as time-ordered events to Kafka topics. Simulates the full order lifecycle: ORDER → ITEMS → PAYMENT → SHIP → DELIVER → REVIEW Usage: python simulator.py --speed 1000 --data-dir ./data speed=1 → real-time (25 months) speed=100 → ~6 hours speed=1000 → ~36 minutes speed=10000 → ~3.6 minutes """ import os import sys import json import time import logging import argparse from datetime import datetime, timedelta from dataclasses import dataclass, asdict from typing import List, Optional from pathlib import Path import pandas as pd # Lazy import Kafka to allow data loading/testing without running Kafka server try: from confluent_kafka import Producer from confluent_kafka.serialization import SerializationContext, MessageField from confluent_kafka.schema_registry import SchemaRegistryClient from confluent_kafka.schema_registry.avro import AvroSerializer _KAFKA_AVAILABLE = True except ImportError: _KAFKA_AVAILABLE = False Producer = None SerializationContext = None MessageField = None SchemaRegistryClient = None AvroSerializer = None # ============================================================ # CONFIGURATION # ============================================================ logging.basicConfig( level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s', datefmt='%Y-%m-%d %H:%M:%S' ) logger = logging.getLogger(__name__) # Kafka Topics TOPICS = { 'order_created': 'ecom.orders.created', 'order_items': 'ecom.orders.items', 'order_payments': 'ecom.orders.payments', 'order_status': 'ecom.orders.status_changed', 'order_delivered': 'ecom.orders.delivered', 'review_submitted': 'ecom.reviews.submitted', } # ============================================================ # EVENT DATACLASSES # ============================================================ @dataclass class Event: """Base event to be sent to Kafka""" timestamp: str # ISO format string topic: str key: str # order_id payload: dict event_type: str def __lt__(self, other): return self.timestamp < other.timestamp # ============================================================ # STREAMING SIMULATOR # ============================================================ class OlistStreamSimulator: """ Reads Olist CSV files from Kaggle dataset and replays events in chronological order through Kafka topics, simulating real-time e-commerce data flow. """ def __init__( self, data_dir: str, kafka_bootstrap: str = 'localhost:9092', schema_registry_url: str = 'http://localhost:8081', speed_factor: float = 1000.0, ): self.data_dir = Path(data_dir) self.speed_factor = speed_factor self.events: List[Event] = [] self.stats = {topic: 0 for topic in TOPICS.values()} # Kafka Producer if _KAFKA_AVAILABLE: self.producer = Producer({ 'bootstrap.servers': kafka_bootstrap, 'client.id': 'olist-simulator', 'linger.ms': 5, 'batch.num.messages': 1000, 'queue.buffering.max.messages': 100000, 'compression.type': 'snappy', }) else: logger.warning("Kafka library not available. Data loading will work, but streaming to Kafka will fail.") self.producer = None logger.info(f"Simulator initialized: speed={speed_factor}x, data_dir={data_dir}") def _delivery_callback(self, err, msg): """Callback for Kafka producer delivery reports""" if err: logger.error(f"Message delivery failed: {err}") def load_data(self): """Load all CSV files from Kaggle dataset and build the event timeline""" logger.info("Loading Olist CSV files from Kaggle dataset...") # Kaggle dataset file paths (olist_*_dataset.csv naming convention) orders_path = self.data_dir / 'olist_orders_dataset.csv' items_path = self.data_dir / 'olist_order_items_dataset.csv' payments_path = self.data_dir / 'olist_order_payments_dataset.csv' reviews_path = self.data_dir / 'olist_order_reviews_dataset.csv' customers_path = self.data_dir / 'olist_customers_dataset.csv' products_path = self.data_dir / 'olist_products_dataset.csv' sellers_path = self.data_dir / 'olist_sellers_dataset.csv' # Validate required files exist required_files = [orders_path, items_path, payments_path, reviews_path] for f in required_files: if not f.exists(): raise FileNotFoundError( f"Required file not found: {f}\n" f"Please download the dataset from Kaggle:\n" f" kaggle datasets download -d olistbr/brazilian-ecommerce\n" f" unzip brazilian-ecommerce.zip -d {self.data_dir}" ) # Load CSVs with timestamp parsing orders = pd.read_csv( orders_path, parse_dates=[ 'order_purchase_timestamp', 'order_approved_at', 'order_delivered_carrier_date', 'order_delivered_customer_date', 'order_estimated_delivery_date' ] ) items = pd.read_csv( items_path, parse_dates=['shipping_limit_date'] ) payments = pd.read_csv(payments_path) reviews = pd.read_csv( reviews_path, parse_dates=['review_creation_date', 'review_answer_timestamp'] ) customers = pd.read_csv(customers_path) products = pd.read_csv(products_path) sellers = pd.read_csv(sellers_path) logger.info( f"Loaded: {len(orders)} orders, {len(items)} items, " f"{len(payments)} payments, {len(reviews)} reviews, " f"{len(customers)} customers, {len(products)} products, " f"{len(sellers)} sellers" ) # Build event timeline logger.info("Building event timeline...") # Pre-index for faster lookups items_by_order = items.groupby('order_id') payments_by_order = payments.groupby('order_id') reviews_by_order = reviews.groupby('order_id') # Sort orders by purchase timestamp orders = orders.sort_values('order_purchase_timestamp').dropna( subset=['order_purchase_timestamp'] ) total = len(orders) for idx, (_, order) in enumerate(orders.iterrows()): if idx % 10000 == 0: logger.info(f"Processing order {idx}/{total} ({idx/total*100:.1f}%)") order_id = order['order_id'] purchase_ts = order['order_purchase_timestamp'] if pd.isna(purchase_ts): continue # ---- Event 1: ORDER CREATED ---- self.events.append(Event( timestamp=purchase_ts.isoformat(), topic=TOPICS['order_created'], key=order_id, payload={ 'order_id': order_id, 'customer_id': str(order['customer_id']), 'order_status': str(order.get('order_status', 'created')), 'order_purchase_timestamp': purchase_ts.isoformat(), 'event_type': 'ORDER_CREATED', 'event_time': purchase_ts.isoformat(), }, event_type='ORDER_CREATED' )) # ---- Event 2: ITEMS ADDED (30 seconds after order) ---- if order_id in items_by_order.groups: order_items = items_by_order.get_group(order_id) items_ts = purchase_ts + timedelta(seconds=30) for _, item in order_items.iterrows(): shipping_limit = item.get('shipping_limit_date') self.events.append(Event( timestamp=items_ts.isoformat(), topic=TOPICS['order_items'], key=order_id, payload={ 'order_id': order_id, 'order_item_id': int(item['order_item_id']), 'product_id': str(item['product_id']), 'seller_id': str(item['seller_id']), 'shipping_limit_date': str(shipping_limit) if pd.notna(shipping_limit) else None, 'price': float(item['price']), 'freight_value': float(item['freight_value']), 'event_type': 'ITEM_ADDED', 'event_time': items_ts.isoformat(), }, event_type='ITEM_ADDED' )) # ---- Event 3: PAYMENT CAPTURED (at approval time) ---- if pd.notna(order['order_approved_at']) and order_id in payments_by_order.groups: approved_ts = order['order_approved_at'] order_payments = payments_by_order.get_group(order_id) for _, pay in order_payments.iterrows(): self.events.append(Event( timestamp=approved_ts.isoformat(), topic=TOPICS['order_payments'], key=order_id, payload={ 'order_id': order_id, 'payment_sequential': int(pay['payment_sequential']), 'payment_type': str(pay['payment_type']), 'payment_installments': int(pay['payment_installments']), 'payment_value': float(pay['payment_value']), 'event_type': 'PAYMENT_CAPTURED', 'event_time': approved_ts.isoformat(), }, event_type='PAYMENT_CAPTURED' )) # ---- Event 4: ORDER SHIPPED (carrier date) ---- if pd.notna(order['order_delivered_carrier_date']): shipped_ts = order['order_delivered_carrier_date'] self.events.append(Event( timestamp=shipped_ts.isoformat(), topic=TOPICS['order_status'], key=order_id, payload={ 'order_id': order_id, 'old_status': str(order.get('order_status', 'processing')), 'new_status': 'shipped', 'timestamp': shipped_ts.isoformat(), 'event_type': 'STATUS_CHANGED', 'event_time': shipped_ts.isoformat(), }, event_type='STATUS_CHANGED' )) # ---- Event 5: ORDER DELIVERED ---- if pd.notna(order['order_delivered_customer_date']): delivered_ts = order['order_delivered_customer_date'] estimated = order['order_estimated_delivery_date'] delay_days = None is_late = False if pd.notna(estimated): delay_days = int((delivered_ts - estimated).days) is_late = bool(delivered_ts > estimated) self.events.append(Event( timestamp=delivered_ts.isoformat(), topic=TOPICS['order_delivered'], key=order_id, payload={ 'order_id': order_id, 'order_delivered_carrier_date': str(order['order_delivered_carrier_date']) if pd.notna(order['order_delivered_carrier_date']) else None, 'order_delivered_customer_date': delivered_ts.isoformat(), 'order_estimated_delivery_date': str(estimated) if pd.notna(estimated) else None, 'delivery_delay_days': delay_days, 'is_late': is_late, 'event_type': 'ORDER_DELIVERED', 'event_time': delivered_ts.isoformat(), }, event_type='ORDER_DELIVERED' )) # ---- Event 6: REVIEW SUBMITTED ---- if order_id in reviews_by_order.groups: order_reviews = reviews_by_order.get_group(order_id) for _, review in order_reviews.iterrows(): review_ts = review.get('review_answer_timestamp') if pd.notna(review_ts): comment_title = review.get('review_comment_title') comment_msg = review.get('review_comment_message') review_creation = review.get('review_creation_date') self.events.append(Event( timestamp=review_ts.isoformat(), topic=TOPICS['review_submitted'], key=order_id, payload={ 'review_id': str(review['review_id']), 'order_id': order_id, 'review_score': int(review['review_score']), 'review_comment_title': str(comment_title) if pd.notna(comment_title) else None, 'review_comment_message': str(comment_msg) if pd.notna(comment_msg) else None, 'review_creation_date': str(review_creation) if pd.notna(review_creation) else None, 'review_answer_timestamp': review_ts.isoformat(), 'event_type': 'REVIEW_SUBMITTED', 'event_time': review_ts.isoformat(), }, event_type='REVIEW_SUBMITTED' )) # Sort all events by timestamp self.events.sort() logger.info(f"Timeline built: {len(self.events)} total events") # Print event distribution event_types = {} for e in self.events: event_types[e.event_type] = event_types.get(e.event_type, 0) + 1 for et, count in sorted(event_types.items()): logger.info(f" {et}: {count:,} events") def run(self, max_events: Optional[int] = None): """ Replay events with time-scaled delays. Args: max_events: Optional limit on number of events to send (for testing) """ if not self.events: self.load_data() total_events = len(self.events) if max_events: total_events = min(max_events, total_events) logger.info(f"Starting replay: {total_events:,} events at {self.speed_factor}x speed") # Calculate expected duration if len(self.events) >= 2: first_ts = datetime.fromisoformat(self.events[0].timestamp) last_ts = datetime.fromisoformat(self.events[min(total_events-1, len(self.events)-1)].timestamp) real_duration = (last_ts - first_ts).total_seconds() simulated_duration = real_duration / self.speed_factor logger.info(f"Real time span: {real_duration/86400:.1f} days") logger.info(f"Simulated duration: {simulated_duration/60:.1f} minutes") start_time = time.time() prev_event_time = datetime.fromisoformat(self.events[0].timestamp) events_sent = 0 for i, event in enumerate(self.events[:total_events]): # Calculate delay current_event_time = datetime.fromisoformat(event.timestamp) time_diff = (current_event_time - prev_event_time).total_seconds() if time_diff > 0: sleep_time = time_diff / self.speed_factor # Cap sleep to avoid long pauses sleep_time = min(sleep_time, 5.0) if sleep_time > 0.001: time.sleep(sleep_time) # Send to Kafka if self.producer is None: # Kafka not available — simulate send (for testing/data loading only) self.stats[event.topic] = self.stats.get(event.topic, 0) + 1 events_sent += 1 if events_sent % 5000 == 0: elapsed = time.time() - start_time rate = events_sent / elapsed if elapsed > 0 else 0 logger.info( f"Progress: {events_sent:,}/{total_events:,} events " f"({events_sent/total_events*100:.1f}%) | " f"Rate: {rate:.0f} events/sec | " f"Simulated time: {current_event_time}" ) continue try: self.producer.produce( topic=event.topic, key=event.key.encode('utf-8'), value=json.dumps(event.payload).encode('utf-8'), callback=self._delivery_callback, ) self.stats[event.topic] = self.stats.get(event.topic, 0) + 1 events_sent += 1 except BufferError: logger.warning("Producer buffer full, flushing...") self.producer.flush(timeout=10) self.producer.produce( topic=event.topic, key=event.key.encode('utf-8'), value=json.dumps(event.payload).encode('utf-8'), callback=self._delivery_callback, ) events_sent += 1 # Periodic flush and progress if events_sent % 5000 == 0: if self.producer is not None: self.producer.flush(timeout=5) elapsed = time.time() - start_time rate = events_sent / elapsed if elapsed > 0 else 0 logger.info( f"Progress: {events_sent:,}/{total_events:,} events " f"({events_sent/total_events*100:.1f}%) | " f"Rate: {rate:.0f} events/sec | " f"Simulated time: {current_event_time}" ) prev_event_time = current_event_time # Final flush if self.producer is not None: self.producer.flush(timeout=30) elapsed = time.time() - start_time logger.info(f"\n{'='*60}") logger.info(f"REPLAY COMPLETE") logger.info(f"{'='*60}") logger.info(f"Total events sent: {events_sent:,}") logger.info(f"Total time: {elapsed:.1f} seconds ({elapsed/60:.1f} minutes)") logger.info(f"Average rate: {events_sent/elapsed:.0f} events/sec") logger.info(f"\nEvents per topic:") for topic, count in sorted(self.stats.items()): logger.info(f" {topic}: {count:,}") # ============================================================ # CLI ENTRY POINT # ============================================================ def main(): parser = argparse.ArgumentParser( description='Olist E-commerce Streaming Simulator (Kaggle Dataset)', formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" Examples: # Quick test (first 1000 events) python simulator.py --data-dir ./brazilian-ecommerce --speed 10000 --max-events 1000 # Full replay at 1000x speed (~36 min) python simulator.py --data-dir ./brazilian-ecommerce --speed 1000 # Real-time replay python simulator.py --data-dir ./brazilian-ecommerce --speed 1 Setup: 1. Download dataset from Kaggle: kaggle datasets download -d olistbr/brazilian-ecommerce unzip brazilian-ecommerce.zip -d ./brazilian-ecommerce 2. Ensure Kafka is running (see docker-compose.yml) 3. Run simulator: python streaming_simulator/simulator.py --data-dir ./brazilian-ecommerce """ ) parser.add_argument( '--data-dir', type=str, default=os.environ.get('DATA_DIR', './data'), help='Directory containing Kaggle Olist CSV files (olist_orders_dataset.csv, etc.)' ) parser.add_argument( '--kafka-bootstrap', type=str, default=os.environ.get('KAFKA_BOOTSTRAP_SERVERS', 'localhost:9092'), help='Kafka bootstrap servers' ) parser.add_argument( '--schema-registry', type=str, default=os.environ.get('SCHEMA_REGISTRY_URL', 'http://localhost:8081'), help='Schema Registry URL' ) parser.add_argument( '--speed', type=float, default=float(os.environ.get('SPEED_FACTOR', '1000')), help='Speed factor (1=real-time, 1000=fast)' ) parser.add_argument( '--max-events', type=int, default=None, help='Maximum events to send (for testing)' ) args = parser.parse_args() simulator = OlistStreamSimulator( data_dir=args.data_dir, kafka_bootstrap=args.kafka_bootstrap, schema_registry_url=args.schema_registry, speed_factor=args.speed, ) simulator.load_data() simulator.run(max_events=args.max_events) if __name__ == '__main__': main()