import requests
import json
import time
import threading
from datetime import datetime
from collections import deque

class LogScaleBatchClient:
    """
    Batching client for LogScale HTTP API.
    """
    
    def __init__(self, url, token, batch_size=100, batch_timeout=5.0):
        """
        Initialize the batching client.
        
        Args:
            url (str): LogScale ingestion URL
            token (str): Ingest token
            batch_size (int): Maximum events per batch
            batch_timeout (float): Maximum seconds to wait before flushing
        """
        self.url = url
        self.token = token
        self.batch_size = batch_size
        self.batch_timeout = batch_timeout
        
        self.buffer = deque()
        self.lock = threading.Lock()
        self.last_flush = time.time()
        
        # Start background flush thread
        self.flush_thread = threading.Thread(target=self._flush_loop, daemon=True)
        self.flush_thread.start()
    
    def log(self, message, level="INFO", **kwargs):
        """
        Add a log event to the batch.
        
        Args:
            message (str): Log message
            level (str): Log level
            **kwargs: Additional attributes
        """
        event = {
            "timestamp": datetime.utcnow().isoformat() + "Z",
            "attributes": {
                "message": message,
                "level": level,
                **kwargs
            }
        }
        
        with self.lock:
            self.buffer.append(event)
            
            # Flush if batch size reached
            if len(self.buffer) >= self.batch_size:
                self._flush()
    
    def _flush(self):
        """
        Flush the current batch to LogScale.
        """
        if not self.buffer:
            return
        
        # Get events from buffer
        events = list(self.buffer)
        self.buffer.clear()
        self.last_flush = time.time()
        
        # Send to LogScale
        headers = {
            "Authorization": f"Bearer {self.token}",
            "Content-Type": "application/json"
        }
        
        payload = [{"events": events}]
        
        try:
            response = requests.post(
                self.url,
                headers=headers,
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            print(f"Flushed {len(events)} events to LogScale")
            
        except Exception as e:
            print(f"Error flushing to LogScale: {str(e)}")
            # Re-add events to buffer for retry
            with self.lock:
                self.buffer.extendleft(reversed(events))
    
    def _flush_loop(self):
        """
        Background thread to flush based on timeout.
        """
        while True:
            time.sleep(1)
            
            with self.lock:
                if self.buffer and (time.time() - self.last_flush) >= self.batch_timeout:
                    self._flush()
    
    def flush(self):
        """
        Manually flush all pending events.
        """
        with self.lock:
            self._flush()
    
    def close(self):
        """
        Flush and close the client.
        """
        self.flush()

# Example usage
client = LogScaleBatchClient(
    url="https://cloud.humio.com/api/v1/ingest/humio-structured",
    token="YOUR_INGEST_TOKEN_HERE",
    batch_size=100,
    batch_timeout=5.0
)

# Log events (automatically batched)
for i in range(250):
    client.log(
        message=f"Event {i}",
        level="INFO",
        iteration=i
    )

# Ensure all events are sent
client.close()

import requests
import json
import gzip

def send_to_logscale_compressed(events, tags=None):
    """
    Send events to LogScale with gzip compression.
    
    Args:
        events (list): List of event dictionaries
        tags (dict): Optional tags
    
    Returns:
        bool: True if successful
    """
    
    headers = {
        "Authorization": f"Bearer {INGEST_TOKEN}",
        "Content-Type": "application/json",
        "Content-Encoding": "gzip"
    }
    
    payload = [
        {
            "tags": tags or {},
            "events": events
        }
    ]
    
    # Compress payload
    json_data = json.dumps(payload).encode('utf-8')
    compressed_data = gzip.compress(json_data)
    
    print(f"Original size: {len(json_data)} bytes")
    print(f"Compressed size: {len(compressed_data)} bytes")
    print(f"Compression ratio: {len(compressed_data)/len(json_data):.2%}")
    
    try:
        response = requests.post(
            LOGSCALE_URL,
            headers=headers,
            data=compressed_data,
            timeout=30
        )
        response.raise_for_status()
        return True
        
    except Exception as e:
        print(f"Error: {str(e)}")
        return False

import requests
import time
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

def create_session_with_retries():
    """
    Create a requests session with retry logic.
    
    Returns:
        requests.Session: Configured session
    """
    session = requests.Session()
    
    # Configure retry strategy
    retry_strategy = Retry(
        total=5,                    # Maximum number of retries
        backoff_factor=1,           # Wait 1, 2, 4, 8, 16 seconds
        status_forcelist=[429, 500, 502, 503, 504],  # Retry on these status codes
        allowed_methods=["POST"]    # Retry POST requests
    )
    
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    
    return session

def send_to_logscale_with_retry(events, tags=None, max_retries=5):
    """
    Send events to LogScale with custom retry logic.
    
    Args:
        events (list): List of event dictionaries
        tags (dict): Optional tags
        max_retries (int): Maximum retry attempts
    
    Returns:
        bool: True if successful
    """
    
    headers = {
        "Authorization": f"Bearer {INGEST_TOKEN}",
        "Content-Type": "application/json"
    }
    
    payload = [
        {
            "tags": tags or {},
            "events": events
        }
    ]
    
    session = create_session_with_retries()
    
    for attempt in range(max_retries):
        try:
            response = session.post(
                LOGSCALE_URL,
                headers=headers,
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            print(f"Successfully sent {len(events)} events")
            return True
            
        except requests.exceptions.HTTPError as e:
            if e.response.status_code == 429:
                # Rate limited - wait longer
                wait_time = 2 ** attempt * 2
                print(f"Rate limited. Waiting {wait_time}s before retry {attempt + 1}/{max_retries}")
                time.sleep(wait_time)
            elif e.response.status_code >= 500:
                # Server error - retry with backoff
                wait_time = 2 ** attempt
                print(f"Server error. Waiting {wait_time}s before retry {attempt + 1}/{max_retries}")
                time.sleep(wait_time)
            else:
                # Client error - don't retry
                print(f"Client error: {e.response.status_code}")
                return False
                
        except requests.exceptions.RequestException as e:
            # Network error - retry with backoff
            wait_time = 2 ** attempt
            print(f"Network error. Waiting {wait_time}s before retry {attempt + 1}/{max_retries}")
            time.sleep(wait_time)
    
    print(f"Failed after {max_retries} attempts")
    return False

import requests
import json
import os
import time
from pathlib import Path

class BufferedLogScaleClient:
    """
    LogScale client with disk-based buffering.
    """
    
    def __init__(self, url, token, buffer_dir="/tmp/logscale_buffer"):
        """
        Initialize buffered client.
        
        Args:
            url (str): LogScale ingestion URL
            token (str): Ingest token
            buffer_dir (str): Directory for buffering failed requests
        """
        self.url = url
        self.token = token
        self.buffer_dir = Path(buffer_dir)
        self.buffer_dir.mkdir(parents=True, exist_ok=True)
    
    def send(self, events, tags=None):
        """
        Send events to LogScale with buffering.
        
        Args:
            events (list): List of event dictionaries
            tags (dict): Optional tags
        
        Returns:
            bool: True if sent or buffered successfully
        """
        
        headers = {
            "Authorization": f"Bearer {self.token}",
            "Content-Type": "application/json"
        }
        
        payload = [
            {
                "tags": tags or {},
                "events": events
            }
        ]
        
        try:
            response = requests.post(
                self.url,
                headers=headers,
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            print(f"Successfully sent {len(events)} events")
            
            # Try to send buffered events
            self._send_buffered()
            return True
            
        except Exception as e:
            print(f"Error sending to LogScale: {str(e)}")
            print("Buffering events to disk")
            
            # Save to buffer
            buffer_file = self.buffer_dir / f"buffer_{int(time.time() * 1000)}.json"
            with open(buffer_file, 'w') as f:
                json.dump(payload, f)
            
            return True
    
    def _send_buffered(self):
        """
        Attempt to send buffered events.
        """
        buffer_files = sorted(self.buffer_dir.glob("buffer_*.json"))
        
        for buffer_file in buffer_files:
            try:
                with open(buffer_file, 'r') as f:
                    payload = json.load(f)
                
                headers = {
                    "Authorization": f"Bearer {self.token}",
                    "Content-Type": "application/json"
                }
                
                response = requests.post(
                    self.url,
                    headers=headers,
                    json=payload,
                    timeout=30
                )
                response.raise_for_status()
                
                # Success - delete buffer file
                buffer_file.unlink()
                print(f"Sent buffered events from {buffer_file.name}")
                
            except Exception as e:
                print(f"Error sending buffered events: {str(e)}")
                # Keep buffer file for next attempt
                break

# Example usage
client = BufferedLogScaleClient(
    url="https://cloud.humio.com/api/v1/ingest/humio-structured",
    token="YOUR_INGEST_TOKEN_HERE"
)

events = [
    {
        "timestamp": "2024-01-15T10:30:00.000Z",
        "attributes": {
            "message": "Test event",
            "level": "INFO"
        }
    }
]

client.send(events)

def send_with_parser(events, parser_name, tags=None):
    """
    Send events to LogScale with specific parser.
    
    Args:
        events (list): List of event dictionaries
        parser_name (str): Name of parser to use
        tags (dict): Optional tags
    
    Returns:
        bool: True if successful
    """
    
    headers = {
        "Authorization": f"Bearer {INGEST_TOKEN}",
        "Content-Type": "application/json"
    }
    
    # Add parser to tags
    if tags is None:
        tags = {}
    tags["@parser"] = parser_name
    
    payload = [
        {
            "tags": tags,
            "events": events
        }
    ]
    
    try:
        response = requests.post(
            LOGSCALE_URL,
            headers=headers,
            json=payload,
            timeout=30
        )
        response.raise_for_status()
        return True
        
    except Exception as e:
        print(f"Error: {str(e)}")
        return False

# Example: Use JSON parser
events = [
    {
        "timestamp": "2024-01-15T10:30:00.000Z",
        "attributes": {
            "message": "Test event",
            "level": "INFO"
        }
    }
]

send_with_parser(events, parser_name="json")

import asyncio
import aiohttp
import json
from datetime import datetime

class AsyncLogScaleClient:
    """
    Async LogScale client for non-blocking operations.
    """
    
    def __init__(self, url, token):
        """
        Initialize async client.
        
        Args:
            url (str): LogScale ingestion URL
            token (str): Ingest token
        """
        self.url = url
        self.token = token
        self.session = None
    
    async def __aenter__(self):
        """Context manager entry."""
        self.session = aiohttp.ClientSession()
        return self
    
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        """Context manager exit."""
        if self.session:
            await self.session.close()
    
    async def send(self, events, tags=None):
        """
        Send events to LogScale asynchronously.
        
        Args:
            events (list): List of event dictionaries
            tags (dict): Optional tags
        
        Returns:
            bool: True if successful
        """
        
        headers = {
            "Authorization": f"Bearer {self.token}",
            "Content-Type": "application/json"
        }
        
        payload = [
            {
                "tags": tags or {},
                "events": events
            }
        ]
        
        try:
            async with self.session.post(
                self.url,
                headers=headers,
                json=payload,
                timeout=aiohttp.ClientTimeout(total=30)
            ) as response:
                response.raise_for_status()
                print(f"Successfully sent {len(events)} events")
                return True
                
        except Exception as e:
            print(f"Error: {str(e)}")
            return False

# Example usage
async def main():
    async with AsyncLogScaleClient(
        url="https://cloud.humio.com/api/v1/ingest/humio-structured",
        token="YOUR_INGEST_TOKEN_HERE"
    ) as client:
        
        # Send multiple batches concurrently
        tasks = []
        for i in range(10):
            events = [
                {
                    "timestamp": datetime.utcnow().isoformat() + "Z",
                    "attributes": {
                        "message": f"Event from batch {i}",
                        "level": "INFO",
                        "batch": i
                    }
                }
            ]
            tasks.append(client.send(events))
        
        # Wait for all sends to complete
        results = await asyncio.gather(*tasks)
        print(f"Sent {sum(results)} batches successfully")

# Run async main
asyncio.run(main())