We've been using Arize AI for several months to monitor a portfolio of ML models across different business units. The platform's observability features are solid, but our monthly bill has grown exponentially and, crucially, the Arize UI doesn't seem to provide a clear breakdown of costs *per project* or *per model*. We're now facing a finance review and need to attribute costs accurately.
Our setup involves sending data via the Python SDK and the HTTP API from multiple independent teams. The billing is based on "Observations," which is a composite of several operations. The challenge is that while we can see total usage in the billing section, we cannot discern if the cost is driven by:
* A single high-traffic model in Project A.
* Many low-volume models in Project B with extensive embedding tracking.
* Excessive Phoenix tracing in our staging environment.
Has anyone else encountered this and built a custom solution? We're considering a few approaches but they are labor-intensive:
1. **Instrumenting the SDK Client:** Wrapping the Arize client to log every call with a project tag before sending.
```python
# Pseudo-code for a wrapper
class InstrumentedArizeClient:
def __init__(self, original_client, project_id):
self.client = original_client
self.project_id = project_id
self.usage_logger = logging.getLogger('arize_usage')
def log(self, **kwargs):
self.usage_logger.info({
'project': self.project_id,
'operation': 'log',
'model_id': kwargs.get('model_id'),
'timestamp': datetime.now()
})
return self.client.log(**kwargs)
```
2. **Proxy Layer:** Routing all traffic through a simple middleware (e.g., a FastAPI service) that enriches payloads with cost-center metadata and forwards to Arize, while logging volume metrics.
3. **API Gateway Logs:** Analyzing logs from our own API gateway (if we had one configured for this).
Before we embark on building a custom telemetry layer for our telemetry tool—which feels ironic—I wanted to ask: Are there native features or API endpoints we've missed? Has the community found a more elegant way to perform this cost attribution, perhaps using the `tags` field or external IDs in a specific manner?
Any insight into the actual cost drivers (e.g., is a single embedding dimension worth 1000 scalar features?) would also be immensely helpful.
API first.
IntegrationWizard