Log Event

import json
import time

# User message event
user_content = {
    "message": "Can you help me book a flight to Paris?",
    "user_id": "user-123",
    "channel": "web_chat"
}

user_schema = {
    "type": "object",
    "properties": {
        "message": {
            "type": "string",
            "description": "User's message text"
        },
        "user_id": {
            "type": "string",
            "description": "Unique user identifier"
        },
        "channel": {
            "type": "string",
            "enum": ["web_chat", "mobile", "api"]
        }
    },
    "required": ["message", "user_id"]
}

response = log_event(
    event_type="user",
    trace_id=trace_id,
    timestamp=time.time(),
    content=json.dumps(user_content),
    schema=json.dumps(user_schema)
)

// User message event
const userContent = {
  message: "Can you help me book a flight to Paris?",
  user_id: "user-123",
  channel: "web_chat"
};

const userSchema = {
  type: "object",
  properties: {
    message: {
      type: "string",
      description: "User's message text"
    },
    user_id: {
      type: "string", 
      description: "Unique user identifier"
    },
    channel: {
      type: "string",
      enum: ["web_chat", "mobile", "api"]
    }
  },
  required: ["message", "user_id"]
};

const response = await logEvent({
  event_type: "user",
  trace_id: traceId,
  timestamp: Date.now() / 1000,
  content: JSON.stringify(userContent),
  schema: JSON.stringify(userSchema)
});

# Tool call event
tool_content = {
    "location": "Paris, France",
    "check_in": "2024-03-15",
    "check_out": "2024-03-20",
    "guests": 2
}

tool_schema = {
    "type": "function",
    "name": "search_hotels",
    "description": "Search for available hotels",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "Destination city"
            },
            "check_in": {
                "type": "string",
                "format": "date"
            },
            "check_out": {
                "type": "string",
                "format": "date"
            },
            "guests": {
                "type": "integer",
                "minimum": 1,
                "maximum": 10
            }
        },
        "required": ["location", "check_in", "check_out"]
    }
}

response = log_event(
    event_type="tool",
    trace_id=trace_id,
    timestamp=time.time(),
    content=json.dumps(tool_content),
    schema=json.dumps(tool_schema)
)

// Tool call event
const toolContent = {
  location: "Paris, France",
  check_in: "2024-03-15",
  check_out: "2024-03-20",
  guests: 2
};

const toolSchema = {
  type: "function",
  name: "search_hotels",
  description: "Search for available hotels",
  parameters: {
    type: "object",
    properties: {
      location: {
        type: "string",
        description: "Destination city"
      },
      check_in: {
        type: "string",
        format: "date"
      },
      check_out: {
        type: "string",
        format: "date"
      },
      guests: {
        type: "integer",
        minimum: 1,
        maximum: 10
      }
    },
    required: ["location", "check_in", "check_out"]
  }
};

const response = await logEvent({
  event_type: "tool",
  trace_id: traceId,
  timestamp: Date.now() / 1000,
  content: JSON.stringify(toolContent),
  schema: JSON.stringify(toolSchema)
});

import json
import time
import requests

class FabraixLogger:
    def __init__(self, api_key, trace_id):
        self.api_key = api_key
        self.trace_id = trace_id
        self.base_url = "https://api.fabraix.com/v1"
    
    def log_event(self, event_type, content, schema):
        """Log an event to Fabraix"""
        response = requests.post(
            f"{self.base_url}/event",
            headers={
                "x-api-key": self.api_key,
                "Content-Type": "application/json"
            },
            json={
                "event_type": event_type,
                "trace_id": self.trace_id,
                "timestamp": time.time(),
                "content": json.dumps(content),
                "schema": json.dumps(schema)
            }
        )
        return response.json()
    
    def log_user_message(self, message, user_id):
        """Log a user message"""
        return self.log_event(
            event_type="user",
            content={
                "message": message,
                "user_id": user_id
            },
            schema={
                "type": "object",
                "properties": {
                    "message": {"type": "string"},
                    "user_id": {"type": "string"}
                }
            }
        )
    
    def log_tool_call(self, tool_name, arguments, result=None):
        """Log a tool call"""
        content = {
            "tool": tool_name,
            "arguments": arguments
        }
        if result:
            content["result"] = result
        
        return self.log_event(
            event_type="tool",
            content=content,
            schema={
                "type": "object",
                "properties": {
                    "tool": {"type": "string"},
                    "arguments": {"type": "object"},
                    "result": {"type": "object"}
                }
            }
        )

# Usage
logger = FabraixLogger(api_key="YOUR_KEY", trace_id="abc-123")

# Log conversation flow
logger.log_user_message("Book a flight to Paris", "user-456")
logger.log_tool_call("search_flights", {"destination": "Paris"})
logger.log_tool_call(
    "search_flights",
    {"destination": "Paris"},
    result={"flights": [{"id": "FL123", "price": 299}]}
)

class FabraixLogger {
  constructor(apiKey, traceId) {
    this.apiKey = apiKey;
    this.traceId = traceId;
    this.baseUrl = 'https://api.fabraix.com/v1';
  }
  
  async logEvent(eventType, content, schema) {
    const response = await fetch(`${this.baseUrl}/event`, {
      method: 'POST',
      headers: {
        'x-api-key': this.apiKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        event_type: eventType,
        trace_id: this.traceId,
        timestamp: Date.now() / 1000,
        content: JSON.stringify(content),
        schema: JSON.stringify(schema)
      })
    });
    
    return response.json();
  }
  
  async logUserMessage(message, userId) {
    return this.logEvent(
      'user',
      {
        message: message,
        user_id: userId
      },
      {
        type: 'object',
        properties: {
          message: { type: 'string' },
          user_id: { type: 'string' }
        }
      }
    );
  }
  
  async logToolCall(toolName, args, result = null) {
    const content = {
      tool: toolName,
      arguments: args
    };
    
    if (result) {
      content.result = result;
    }
    
    return this.logEvent(
      'tool',
      content,
      {
        type: 'object',
        properties: {
          tool: { type: 'string' },
          arguments: { type: 'object' },
          result: { type: 'object' }
        }
      }
    );
  }
}

// Usage
const logger = new FabraixLogger('YOUR_KEY', 'abc-123');

// Log conversation flow
await logger.logUserMessage('Book a flight to Paris', 'user-456');
await logger.logToolCall('search_flights', { destination: 'Paris' });
await logger.logToolCall(
  'search_flights',
  { destination: 'Paris' },
  { flights: [{ id: 'FL123', price: 299 }] }
);

{
  "error": {
    "message": "Content does not match provided schema",
    "type": "validation_error",
    "code": "SCHEMA_MISMATCH",
    "details": {
      "missing_field": "user_id",
      "path": "$.user_id"
    }
  }
}

{
  "error": {
    "message": "Trace ID not found",
    "type": "not_found_error",
    "code": "TRACE_NOT_FOUND"
  }
}

{
  "error": {
    "message": "Invalid JSON in content field",
    "type": "parse_error", 
    "code": "INVALID_JSON",
    "details": {
      "position": 45,
      "line": 2
    }
  }
}