packages/traceloop-sdk/tests/datasets/cassettes/test_datasets_operations/test_get_version_csv_failure.yaml (1)

1-55: Ensure comprehensive VCR secret redaction

VCR is currently only filtering the authorization header. To prevent other credentials from leaking into cassettes, update your VCR configuration in packages/traceloop-sdk/tests/conftest.py as follows:

• Include all sensitive headers in filter_headers
• Add filter_query_parameters for any secret params
• (Optional) Use a before_record hook to scrub tokens in bodies

Suggested diff:

--- a/packages/traceloop-sdk/tests/conftest.py
+++ b/packages/traceloop-sdk/tests/conftest.py
@@ -44,7 +44,9 @@ def pytest_configure(config):
     VCR.configure(**{
       "cassette_library_dir": "tests/datasets/cassettes",
       "record_mode": os.getenv("VCR_RECORD_MODE", "none"),
-      "filter_headers": ["authorization"],
+      "filter_headers": [
+        "authorization", "x-api-key", "api-key", "bearer", "basic"
+      ],
+      "filter_query_parameters": ["api_key", "token"],
       "ignore_localhost": True,
       "allow_unused_http_interactions": False,
       "debug_logger": False,

.gitignore (3)

181-182: Clarify intent: ignore Claude directory explicitly

If this is the Claude Code workspace directory, prefer a trailing slash to target the directory and avoid matching files named .claude.

-# Claude
-.claude
+# Claude Code workspace
+.claude/

---

179-179: Also ignore SQLite journal for Chroma DB

Tests/tools can create the SQLite write-ahead/journal file. Add it to avoid accidental commits.

 chroma.sqlite3
+chroma.sqlite3-journal

---

178-178: Typo: “artifcats” → “artifacts”

Small spelling fix in the section header.

-# Test artifcats
+# Test artifacts

packages/traceloop-sdk/traceloop/sdk/client/http.py (3)

44-49: Generalize CSV detection and add a fallback using Content-Disposition.

Some servers use application/csv or set only Content-Disposition. Make CSV detection broader.

-            content_type = response.headers.get('content-type', '').lower()
-            if 'text/csv' in content_type:
+            content_type = response.headers.get('content-type', '').lower()
+            content_disposition = response.headers.get('content-disposition', '').lower()
+            if 'csv' in content_type or ('.csv' in content_disposition):
                 return response.text
             else:
                 return response.json()

---

33-33: Use logging instead of print for library code.

Printing to stdout isn’t ideal for SDKs; use the logging module with proper levels.

Outside these ranges:

import logging
logger = logging.getLogger(__name__)

Then replace prints:

-            print(Fore.RED + f"Error making request to {path}: {str(e)}" + Fore.RESET)
+            logger.error("Error making request to %s: %s", path, e)

Also applies to: 51-51, 64-64, 80-80

---

23-23: Avoid repeating URL construction; centralize _url().

Minor DRY improvement: centralize f"{self.base_url}/v2/{path.lstrip('/')}" in a helper.

Outside these ranges:

def _url(self, path: str) -> str:
    return f"{self.base_url}/v2/{path.lstrip('/')}"

And use:

- response = requests.get(f"{self.base_url}/v2/{path.lstrip('/')}", ...)
+ response = requests.get(self._url(path), ...)

Also applies to: 36-36, 54-54, 67-67

packages/traceloop-sdk/tests/datasets/cassettes/test_datasets_operations/test_get_version_csv.yaml (1)

1-61: LGTM: CSV cassette aligns with HTTPClient CSV handling.

Works with the client’s CSV branch. If tests do string comparisons, consider stripping trailing blank lines for stability.

packages/traceloop-sdk/tests/datasets/test_constants.py (1)

6-75: Tighten constants typing and portability (Final/Decimal/Path).

Nice centralization. Optional improvements:

• Mark constants as Final for clarity.
• Use Decimal for currency-like values to avoid float surprises in assertions.
• Use a portable nonexistent path via pathlib.

Example:

from decimal import Decimal
from pathlib import Path
from typing import Final

class TestConstants:
    LAPTOP_PRICE: Final = Decimal("999.99")
    MOUSE_PRICE: Final = Decimal("29.99")
    NON_EXISTENT_FILE_PATH: Final = str(Path.cwd() / "this_file_should_not_exist_12345.csv")

Also double-check usages where “Price” is modeled as string vs number across tests to avoid type mismatch (string "99.99" vs numeric 99.99).

packages/traceloop-sdk/traceloop/sdk/client/client.py (1)

43-44: Initialize Datasets on Client; consider docstring and future extensibility.

• Please update the Client docstring to mention the new datasets attribute for discoverability.
• Optional: If you anticipate alternate datasets implementations (e.g., mocking), consider allowing injection via an optional constructor arg or a lazy property later.

packages/traceloop-sdk/tests/dataset/cassettes/test_rows_operations/test_dataset_row_operations_api_errors.yaml (1)

1-55: Error-path cassette is sound; consider harmonizing test directory naming.
Interaction is valid and useful. Minor: tests live under both tests/dataset and tests/datasets; consider unifying to reduce confusion.

packages/traceloop-sdk/tests/dataset/cassettes/test_dataset_operations/test_publish_dataset.yaml (1)

1-63: Great happy-path coverage; add failure-path cassettes for robustness.
Consider adding cassettes/tests for:

• 409 conflict on duplicate slug.
• 400 validation errors (e.g., invalid column type or missing required fields).
  This will harden client-side error handling logic.

packages/traceloop-sdk/tests/dataset/cassettes/test_dataset_operations/test_get_dataset_by_version.yaml (1)

15-16: Be explicit with Accept header for CSV.

Request currently sends Accept: /. Prefer Accept: text/csv for content negotiation clarity and to catch server-side regressions.

Also applies to: 31-32

packages/traceloop-sdk/tests/datasets/cassettes/test_datasets_operations/test_get_all_datasets.yaml (1)

23-56: Filter volatile headers and relax matching to reduce flakiness.

Headers like CF-RAY, Date, x-kong-*, cf-cache-status are volatile. Ensure VCR matchers ignore them and they’re filtered from recordings to keep diffs stable.

Add in tests’ VCR setup (e.g., conftest.py):

vcr = VCR(
  match_on=["method", "scheme", "host", "port", "path", "query"],
  filter_headers=["Authorization", "User-Agent", "X-Traceloop-SDK-Version"],
  decode_compressed_response=True,
)

packages/traceloop-sdk/tests/datasets/cassettes/test_datasets_operations/test_get_dataset_by_slug_failure.yaml (1)

52-53: Assert domain-specific exception mapping and preserve server message.

For 404, prefer raising a clear NotFound (or SDK-specific) exception carrying {"error":"Dataset not found"} rather than a generic HTTPError. Tests should assert exception type and message.

Happy to add an error-mapping layer in the client and update tests accordingly.

packages/traceloop-sdk/tests/dataset/cassettes/test_rows_operations/test_create_dataset_and_add_rows.yaml (1)

3-8: Exercise real types (number/boolean) instead of encoding everything as strings.

Columns age/active are typed as string and values "25"/"true". To validate typing/coercion, use number and boolean columns and native values.

Plan:

• Update request to use "number"/"boolean" types and unquoted JSON values.
• Re-record cassette after updating client code and test.

Also applies to: 28-29

packages/traceloop-sdk/tests/datasets/cassettes/test_datasets_operations/test_delete_by_slug.yaml (2)

1-22: Avoid duplicative coverage unless intentional across modules.

There’s another delete-by-slug cassette under tests/dataset. If both exercise the same client path, consider consolidating to reduce maintenance; if they target different layers, keep both but name them accordingly.

---

13-16: Consider filtering X-Traceloop-SDK-Version from recordings.

SDK version churn will create noisy diffs. Filter this header in VCR to make recordings resilient to version bumps.

packages/traceloop-sdk/tests/dataset/test_dataset_operations.py (2)

19-19: Move imports to module level.

Import statements should be at the top of the file rather than inside functions for better readability and performance.

+import time
+import tempfile
+import os
+
 import pytest

-@pytest.mark.vcr
-def test_publish_dataset(datasets):
-    try:
-        # Create a test dataset first, then try to publish it
-        import time

---

24-25: Move imports to module level.

These imports should be moved to the top of the file.

-        import tempfile
-        import os

packages/traceloop-sdk/tests/dataset/test_rows_operations.py (1)

1-5: Consider consolidating imports.

Move the scattered imports from inside functions to the module level for better organization.

Add the missing imports at the top:

 import pytest
+import tempfile
+import os
+import time
-import tempfile
-import os
-import time

packages/traceloop-sdk/tests/dataset/test_columns_operations.py (1)

1-5: Move imports to module level.

Consolidate imports at the top of the file instead of scattering them inside functions.

 import pytest
+import tempfile
+import os
+import time
-import tempfile
-import os
-import time

packages/traceloop-sdk/traceloop/sdk/dataset/column.py (1)

36-37: Unnecessary None check.

The _client is always set in the constructor, making this None check redundant.

-        if self._client is None:
-            raise ValueError("Column must be associated with a dataset to delete")

packages/traceloop-sdk/tests/datasets/test_create_dataset.py (2)

29-31: Move time import to module level.

The time import should be at the top of the file with other imports.

+import time
+
 try:
     import pandas as pd
     PANDAS_AVAILABLE = True
 except ImportError:
     PANDAS_AVAILABLE = False

-        # Use unique slug for testing to avoid conflicts
-        import time
-
         unique_slug = f"test-csv-dataset-{int(time.time())}"

---

69-71: Move time import to module level.

This time import is duplicated and should be moved to the top of the file.

-        # Use unique slug for testing to avoid conflicts
-        import time
-
         unique_slug = f"test-df-dataset-{int(time.time())}"

packages/traceloop-sdk/tests/datasets/test_datasets_operations.py (1)

8-20: Consider using more specific exception types and pytest.raises

The current pattern of catching broad Exception and checking error messages via string containment is fragile. Consider:

1. Using specific exception types if the SDK defines them
2. Using pytest.raises with match parameter for cleaner error assertion

Example refactor for one of the test functions:

-    try:
-        dataset = datasets.get_by_slug("test-qa")
-
-        assert isinstance(dataset, Dataset)
-        # Use flexible assertions that work with recorded data
-        assert dataset.slug == "test-qa"
-        assert hasattr(dataset, "name")
-        assert hasattr(dataset, "description")
-        assert len(dataset.columns) >= 0  # Allow for any number of columns
-        assert len(dataset.rows) >= 0  # Allow for any number of rows
-    except Exception as e:
-        # Allow for expected API errors during recording
-        assert "Failed to get dataset" in str(e) or "404" in str(e) or "401" in str(e)
+    dataset = datasets.get_by_slug("test-qa")
+    
+    assert isinstance(dataset, Dataset)
+    assert dataset.slug == "test-qa"
+    assert hasattr(dataset, "name")
+    assert hasattr(dataset, "description")
+    assert len(dataset.columns) >= 0
+    assert len(dataset.rows) >= 0

For error cases, use pytest.raises:

with pytest.raises(Exception, match=r"(Failed to get dataset|404|401)"):
    datasets.get_by_slug("non-existent")

Also applies to: 24-40, 44-50, 54-62, 89-99

packages/traceloop-sdk/traceloop/sdk/dataset/dataset.py (2)

107-107: Remove unnecessary enumerate

The index from enumerate is not being used.

-    for _, row_obj in enumerate(raw_rows):
+    for row_obj in raw_rows:

---

115-118: Simplify row list initialization

The conditional check for existing rows is unnecessary when appending.

-        if self.rows:
-            self.rows.append(row)
-        else:
-            self.rows = [row]
+        if self.rows is None:
+            self.rows = []
+        self.rows.append(row)

packages/sample-app/sample_app/dataset_example.py (3)

111-111: Add missing type hint for column parameter

The function accepts a column parameter but it's not type-hinted.

-def update_column_example(dataset: Dataset, column: Column):
+def update_column_example(dataset: Dataset, column: Column) -> None:

---

129-129: Add missing type hint for column parameter

The function accepts a column parameter but it's not type-hinted.

-def delete_column_example(dataset: Dataset, column: Column):
+def delete_column_example(dataset: Dataset, column: Column) -> None:

---

163-168: Simplify row existence check

After adding rows, the check for dataset.rows and dataset.rows[0] is redundant. The rows list should exist after add_rows.

-        if dataset.rows and dataset.rows[0]:
-            new_row = dataset.rows[0]
+        if dataset.rows:
+            new_row = dataset.rows[-1]  # Get the last added row
             print(f"Added row with ID: {new_row.id}")
             assert len(dataset.rows) == num_rows + 1
             assert new_row.id in [r.id for r in dataset.rows]
             return new_row

packages/traceloop-sdk/traceloop/sdk/datasets/datasets.py (2)

91-91: Remove unnecessary enumerate

The index from enumerate is not being used.

-            for _, row_data in enumerate(reader):
+            for row_data in reader:

---

169-171: Move import to module level

Importing re inside the function is inefficient as it happens on every call.

Move the import to the top of the file:

 import csv
+import re
 from typing import List, Optional
 from pathlib import Path

Then remove it from the function:

 def _slugify(self, name: str) -> str:
     """Slugify a name"""
-    import re
     
     slug = name.lower()

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

Learnt from: nina-kollman
PR: traceloop/openllmetry#3219
File: packages/traceloop-sdk/traceloop/sdk/datasets/dataset.py:357-360
Timestamp: 2025-08-04T15:35:30.188Z
Learning: In the traceloop SDK Dataset class, the HTTP client's put/get/post/delete methods handle exceptions internally, so explicit exception handling in API wrapper methods may not be necessary according to the user's preference.

Learnt from: nina-kollman
PR: traceloop/openllmetry#3219
File: packages/traceloop-sdk/traceloop/sdk/datasets/dataset.py:357-360
Timestamp: 2025-08-04T15:35:30.188Z
Learning: In the traceloop SDK Dataset class, the established error handling pattern is that HTTP client methods return None on failure (after catching and logging RequestException), and the Dataset API methods check for None return values and raise Exception with descriptive messages. The update_row_api method is inconsistent with this pattern.

packages/traceloop-sdk/traceloop/sdk/client/client.py (2)

23-23: Document the new public attribute client.datasets.

This expands the public API surface. Please add a short note in the Client docstring (and user docs/README if applicable) showing example usage (e.g., client.datasets.from_csv(...)) and include it in any API reference/CHANGELOG.

---

26-31: Avoid evaluating sys.argv[0] at function definition time; prefer None defaults.

Default arguments are evaluated once at import time, which can be surprising in tests and embedded contexts. Also, you’re duplicating the default for api_endpoint both here and in the body. Recommend deferring both to initialization logic.

Apply this diff to the signature:

-    def __init__(
-        self,
-        api_key: str,
-        app_name: str = sys.argv[0],
-        api_endpoint: str = "https://api.traceloop.com",
-    ):
+    def __init__(
+        self,
+        api_key: str,
+        app_name: Optional[str] = None,
+        api_endpoint: Optional[str] = None,
+    ):

Additionally, make these changes outside the selected lines:

• Import Optional from typing at the top of the file.
• Set the fallback for app_name in the initializer.

from typing import Optional

# Replace the current assignment:
self.app_name = app_name
# With:
self.app_name = app_name or sys.argv[0]

packages/traceloop-sdk/pyproject.toml (1)

74-74: Consider using a more specific pandas version constraint.

While >=1.0.0 allows for maximum flexibility, it may lead to compatibility issues with future major versions of pandas. Consider using a more constrained version range to avoid potential breaking changes.

Apply this diff to use a more conservative version constraint:

-pandas = { version = ">=1.0.0", optional = true }
+pandas = { version = ">=1.0.0,<3.0", optional = true }

packages/traceloop-sdk/tests/dataset/cassettes/test_rows_operations/test_add_rows.yaml (1)

119-119: Add newline at end of file.

YAML files should end with a newline character for POSIX compliance and to avoid potential issues with text processing tools.

Apply this diff to add the missing newline:

-version: 1
+version: 1
+

packages/traceloop-sdk/tests/conftest.py (1)

226-233: Consider adding error handling for missing environment variables.

While the fixture provides sensible defaults, it might be helpful to validate that the HTTP client is properly configured, especially when running tests in different environments.

Consider adding validation to ensure the HTTP client is properly initialized:

 @pytest.fixture
 def datasets():
     """Create a Datasets instance with HTTP client for VCR recording/playback"""
     api_key = os.environ.get("TRACELOOP_API_KEY", "fake-key-for-vcr-playback")
     base_url = os.environ.get("TRACELOOP_BASE_URL", "https://api-staging.traceloop.com")
 
+    if not api_key and os.environ.get("CI"):
+        pytest.skip("TRACELOOP_API_KEY not set in CI environment")
+
     http = HTTPClient(base_url=base_url, api_key=api_key, version="1.0.0")
     return Datasets(http)

packages/traceloop-sdk/tests/dataset/test_rows_operations.py (1)

12-12: Consider extracting timestamp generation to a helper function.

The timestamp generation pattern is repeated. Consider extracting it to reduce duplication.

Add a helper function at the module level:

def _generate_unique_slug(prefix: str) -> str:
    """Generate a unique slug with timestamp suffix."""
    return f"{prefix}-{int(time.time())}"

Then update the tests:

-        unique_slug = f"test-rows-{int(time.time())}"
+        unique_slug = _generate_unique_slug("test-rows")

-        unique_slug = f"test-add-rows-{int(time.time())}"
+        unique_slug = _generate_unique_slug("test-add-rows")

Also applies to: 56-56

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/traceloop-sdk/tests/datasets/test_datasets_operations.py (2)

79-79: Replace assert False with raise AssertionError (Ruff B011)

If you keep the try/except structure, at minimum replace assert False to avoid being optimized out under python -O. Prefer the pytest.raises refactor suggested above.

-        assert False, "Expected authentication error"
+        raise AssertionError("Expected authentication error")

---

76-86: Use pytest.raises instead of try/except + assert False (addresses Ruff B011)

This makes the test intent clear, avoids false positives under python -O, and aligns with pytest best practices.

-    try:
-        invalid_datasets.get_all()
-        # If this doesn't raise an exception, the test setup might be wrong
-        assert False, "Expected authentication error"
-    except Exception as exc_info:
-        # Should get authentication error or a generic failure error when using VCR
-        assert (
-            "401" in str(exc_info)
-            or "authentication" in str(exc_info).lower()
-            or "Failed to get datasets" in str(exc_info)
-        )
+    with pytest.raises(Exception) as exc_info:
+        invalid_datasets.get_all()
+    # Should get authentication error or a generic failure error when using VCR
+    assert (
+        "401" in str(exc_info.value)
+        or "authentication" in str(exc_info.value).lower()
+        or "Failed to get datasets" in str(exc_info.value)
+    )

packages/traceloop-sdk/tests/dataset/cassettes/test_rows_operations/test_add_rows.yaml (3)

119-119: Add trailing newline to satisfy YAML linting.

YAMLlint flagged “no new line character at the end of file.” Add a newline after Line 119 to keep linters/CI green.

Apply this diff:

-version: 1
+version: 1
+

---

19-22: Filter dynamic/irrelevant headers in VCR cassettes to reduce churn and noise.

Headers like User-Agent, X-Traceloop-SDK-Version, Date, CF-RAY, and x-kong-* are highly volatile and add noise to diffs. Configure VCR to filter/drop them during recording to stabilize cassettes.

Example (in tests conftest or VCR setup):

import vcr

vcr = vcr.VCR(
    record_mode="once",
    filter_headers=[
        ('user-agent', None),
        ('x-traceloop-sdk-version', None),
        # If you ever record auth, make sure to redact it:
        ('authorization', 'DUMMY'),
    ],
    before_record_response=lambda response: (
        response.update({
            'headers': {
                k: v for k, v in response.get('headers', {}).items()
                if k.lower() not in {
                    'date', 'cf-ray', 'server', 'cf-cache-status',
                    'x-kong-proxy-latency', 'x-kong-upstream-latency',
                    'x-kong-request-id', 'via'
                }
            }
        }) or response
    ),
)

Re-record this cassette after applying the config to remove the volatile headers found on Line 19-22 and Line 30-59 (first interaction), and Line 76-79 and Line 86-115 (second interaction).

Also applies to: 30-59, 76-79, 86-115

---

3-7: Stabilize matching by using a JSON-body matcher instead of raw string body.

The request bodies are JSON strings. If field ordering or serialization changes, cassettes can mismatch. Add a custom vcrpy matcher that compares parsed JSON, ignoring key order.

Example matcher:

# conftest.py
import json
import vcr

def json_body_matcher(r1, r2):
    def parse(body):
        if body is None:
            return None
        if isinstance(body, bytes):
            body = body.decode('utf-8')
        try:
            return json.loads(body)
        except Exception:
            return body
    return parse(r1.body) == parse(r2.body)

my_vcr = vcr.VCR(
    record_mode='once',
    match_on=['method', 'scheme', 'host', 'port', 'path', 'query', 'json-body'],
)

vcr.request.matchers.register('json-body', json_body_matcher)

Then use my_vcr.use_cassette(...) in tests when recording/replaying the interactions involving bodies like in Line 3-7 and Line 64.

Also applies to: 64-64

packages/traceloop-sdk/tests/datasets/cassettes/test_create_dataset/test_create_dataset_from_csv.yaml (3)

20-23: Filter out SDK version and other volatile request headers from VCR matching to reduce brittleness

X-Traceloop-SDK-Version and User-Agent will change as the SDK evolves. If VCR is configured to match headers, future bumps will break cassettes.

Preferred fix: in your tests’ VCR configuration (e.g., conftest.py), filter these headers:

# Example in tests/conftest.py
import vcr

vcr = vcr.VCR(
    filter_headers=[
        ('authorization', 'DUMMY'),
        ('x-traceloop-sdk-version', None),
        ('user-agent', None),
        ('accept-encoding', None),
        ('connection', None),
        ('content-length', None),
    ],
    match_on=['method', 'uri', 'body'],  # avoid matching on headers
)

If you choose to slim the cassette manually, you can remove these request headers from the YAML to make it more stable.

---

31-60: Strip dynamic response headers from cassette to minimize churn

Headers like CF-RAY, Date, Server, x-kong-*, via are infra-generated and change between recordings. Keeping them inflates diffs and can cause false negatives if your harness ever matches headers.

Recommended: configure VCR to filter response headers globally (preferred), or prune them in the cassette. Example VCR setup:

# Example sanitization hook
def before_record_response(response):
    # Remove volatile headers
    for h in [
        'CF-RAY','Date','Server','via','x-kong-request-id',
        'x-kong-proxy-latency','x-kong-upstream-latency',
        'cf-cache-status','Permissions-Policy','referrer-policy',
        'strict-transport-security',
    ]:
        response['headers'].pop(h, None)
    # Normalize header casing too if needed
    return response

vcr = vcr.VCR(before_record_response=before_record_response)

If you prefer a minimal manual edit for this cassette, you can delete those headers under response.headers.

---

31-38: Header normalization: unusual 'x-content-type' key

The header appears as x-content-type: nosniff, which is nonstandard compared to the typical X-Content-Type-Options: nosniff. Likely an upstream proxy normalization. Not an issue for VCR replay, but another reason to strip infra headers to avoid confusion.

Consider filtering or normalizing this header via VCR hooks as suggested above.

packages/traceloop-sdk/tests/dataset/cassettes/test_dataset_operations/test_publish_dataset.yaml (3)

18-21: Avoid recording SDK version in cassettes to reduce churn.

The X-Traceloop-SDK-Version header will change as the SDK evolves, causing unnecessary cassette diffs. Add it to VCR’s filtered headers.

You can filter it in your VCR configuration (e.g., tests/conftest.py):

import vcr

vcr = vcr.VCR(
    filter_headers=[
        ('authorization', '<redacted>'),
        ('X-Traceloop-SDK-Version', '<redacted>'),
    ],
)

---

26-58: Scrub dynamic IDs/timestamps and infra headers from responses to reduce cassette noise.

Fields like id, created_at, updated_at, and infra headers (CF-RAY, x-kong-*, Date, etc.) are highly volatile. Scrubbing them keeps cassettes stable and reviews cleaner without reducing test value.

Consider adding a before_record_response hook to sanitize responses:

# tests/conftest.py
import json
import vcr

def _scrub_response(response):
    # Drop volatile headers
    for h in [
        'Date', 'CF-RAY', 'cf-cache-status', 'x-kong-request-id',
        'x-kong-proxy-latency', 'x-kong-upstream-latency', 'Server', 'via',
        'Permissions-Policy', 'referrer-policy', 'strict-transport-security',
        'x-content-type',
    ]:
        response.get('headers', {}).pop(h, None)

    # Scrub IDs/timestamps in JSON bodies
    body = response.get('body', {})
    headers = response.get('headers', {})
    ctype = (headers.get('Content-Type') or [''])[0]
    if isinstance(body, dict) and 'string' in body and 'application/json' in ctype:
        try:
            data = json.loads(body['string'])
            def walk(node):
                if isinstance(node, dict):
                    for k, v in list(node.items()):
                        if k in ('id', 'dataset_id', 'row_id'):
                            node[k] = '<redacted-id>'
                        elif k in ('created_at', 'updated_at'):
                            node[k] = '<redacted-timestamp>'
                        else:
                            walk(v)
                elif isinstance(node, list):
                    for item in node:
                        walk(item)
            walk(data)
            body['string'] = json.dumps(data, separators=(',', ':'))
        except Exception:
            pass
    return response

vcr = vcr.VCR(
    before_record_response=_scrub_response,
    # Ensure we only match on stable aspects
    match_on=['method', 'uri', 'body'],
)

---

85-114: Filter infra-specific response headers.

CF/ Kong headers and related latencies are environment-specific and add noise. Prefer filtering them out via VCR config as suggested above.

packages/traceloop-sdk/tests/datasets/test_datasets_operations.py (4)

7-14: Drop redundant hasattr checks in positive-path test

The hasattr assertions don’t enforce correctness and can never fail for these attributes on the Dataset object. Keep the test focused on concrete values.

 def test_get_dataset_by_slug(datasets):
     dataset = datasets.get_by_slug("test-qa")

     assert isinstance(dataset, Dataset)
     assert dataset.slug == "test-qa"
-    assert hasattr(dataset, "name")
-    assert hasattr(dataset, "description")

---

17-28: Remove tautological length assertion

len(datasets_list) >= 0 is always true; it adds no value.

 def test_get_all_datasets(datasets):
     datasets_list = datasets.get_all()

     assert isinstance(datasets_list, list)
-    assert len(datasets_list) >= 0

     for dataset in datasets_list:
         assert isinstance(dataset, DatasetMetadata)
         assert hasattr(dataset, "id")
         assert hasattr(dataset, "slug")
         assert hasattr(dataset, "name")

---

8-8: Replace magic strings with shared test constants

Hard-coded slugs and versions (e.g., "test-qa", "v1", "test-csv-dataset-conflict") can drift from cassette data and other tests. Consider centralizing them in tests/datasets/test_constants.py and importing here for consistency.

Also applies to: 33-33, 44-44

---

6-6: Consolidate repeated VCR markers at module level

You can avoid repeating @pytest.mark.vcr by setting a module-level marker.

Add near the top of the file:

pytestmark = pytest.mark.vcr

Also applies to: 16-16, 30-30, 40-40, 52-52, 63-63, 89-89, 99-99

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/sample-app/sample_app/dataset_example.py (3)

306-318: Move OpenAI client instantiation outside the loop to improve performance

The OpenAI client is being recreated for every query iteration, which is inefficient and can lead to unnecessary overhead.

Move the client instantiation outside the loop:

 def create_customer_support_dataset(slug: str) -> Optional[Dataset]:
     """Create a dataset with real OpenAI customer support interactions"""
     print("\n=== Customer Support Dataset with OpenAI ===")
 
     try:
+        # Initialize OpenAI client once
+        client_openai = openai.OpenAI()
+        
         # Sample customer queries
         queries = [
             "How do I reset my password?",
             "My order hasn't arrived yet, what should I do?",
             "Can I return this item after 30 days?",
             "Do you offer international shipping?",
             "What's your refund policy?",
         ]
 
         data = []
         for query in queries:
             try:
                 # Make OpenAI call for customer support response
-                client_openai = openai.OpenAI()
                 response = client_openai.chat.completions.create(

---

386-400: Move OpenAI client instantiation outside the nested loops to improve efficiency

The OpenAI client is being recreated for each phrase-language combination, causing unnecessary overhead.

Move the client instantiation outside both loops:

 def create_translation_dataset(slug: str) -> Optional[Dataset]:
     """Create a dataset with OpenAI translation examples"""
     print("\n=== Translation Dataset with OpenAI ===")
 
     try:
+        # Initialize OpenAI client once
+        client_openai = openai.OpenAI()
+        
         # Sample phrases to translate
         phrases = [
             "Hello, how are you today?",
             "Thank you for your help.",
             "Where is the nearest restaurant?",
             "I would like to book a room.",
             "What time does the store close?",
         ]
 
         languages = ["Spanish", "French", "German", "Italian"]
 
         data = []
         for phrase in phrases:
             for lang in languages:
                 try:
                     # Use OpenAI for translation
-                    client_openai = openai.OpenAI()
                     response = client_openai.chat.completions.create(

---

445-508: Add error handling for main orchestration

The main function lacks error handling, which could cause cascading failures if any operation fails. Individual dataset flows should be isolated from each other.

Wrap each dataset flow in try-except blocks to prevent cascading failures:

 def main():
     print("Traceloop Dataset Examples")
     print("=" * 50)
 
-    ds1 = dataset_from_csv_example("sdk-example-1")
-    if ds1:
-        column = add_column_example(ds1)
-        if column:
-            update_column_example(ds1, column)
-        published_version = publish_dataset_example(ds1)
-        delete_row_example(ds1)
-        if column:
-            delete_column_example(ds1, column)
-        get_dataset_by_slug_example(slug="sdk-example-1")
-        if published_version:
-            get_dataset_by_version_example(
-                slug="sdk-example-1", version=published_version
-            )
-        delete_dataset_example(ds1.slug)
+    try:
+        ds1 = dataset_from_csv_example("sdk-example-1")
+        if ds1:
+            column = add_column_example(ds1)
+            if column:
+                update_column_example(ds1, column)
+            published_version = publish_dataset_example(ds1)
+            delete_row_example(ds1)
+            if column:
+                delete_column_example(ds1, column)
+            get_dataset_by_slug_example(slug="sdk-example-1")
+            if published_version:
+                get_dataset_by_version_example(
+                    slug="sdk-example-1", version=published_version
+                )
+            delete_dataset_example(ds1.slug)
+    except Exception as e:
+        print(f"Error in CSV dataset example: {e}")
 
-    ds2 = dataset_from_dataframe_example("sdk-example-2")
-    if ds2:
-        column = add_column_example(ds2)
-        if column:
-            update_column_example(ds2, column)
-        add_row_example(ds2)
-        update_row_example(ds2)
-        if column:
-            delete_column_example(ds2, column)
-        published_version = publish_dataset_example(ds2)
-        if published_version:
-            get_dataset_by_version_example(
-                slug="sdk-example-2", version=published_version
-            )
-        delete_dataset_example(ds2.slug)
+    try:
+        ds2 = dataset_from_dataframe_example("sdk-example-2")
+        if ds2:
+            column = add_column_example(ds2)
+            if column:
+                update_column_example(ds2, column)
+            add_row_example(ds2)
+            update_row_example(ds2)
+            if column:
+                delete_column_example(ds2, column)
+            published_version = publish_dataset_example(ds2)
+            if published_version:
+                get_dataset_by_version_example(
+                    slug="sdk-example-2", version=published_version
+                )
+            delete_dataset_example(ds2.slug)
+    except Exception as e:
+        print(f"Error in DataFrame dataset example: {e}")
 
     # OpenAI examples
     print("\n" + "=" * 50)
     print("OpenAI Integration Examples")
     print("=" * 50)
 
-    # Customer Support Dataset
-    support_ds = create_customer_support_dataset("openai-support-example")
-    if support_ds:
-        published_version = publish_dataset_example(support_ds)
-        if published_version:
-            get_dataset_by_version_example(
-                slug="openai-support-example", version=published_version
-            )
-        delete_dataset_example(support_ds.slug)
+    try:
+        # Customer Support Dataset
+        support_ds = create_customer_support_dataset("openai-support-example")
+        if support_ds:
+            published_version = publish_dataset_example(support_ds)
+            if published_version:
+                get_dataset_by_version_example(
+                    slug="openai-support-example", version=published_version
+                )
+            delete_dataset_example(support_ds.slug)
+    except Exception as e:
+        print(f"Error in OpenAI customer support example: {e}")
 
-    # Translation Dataset
-    translation_ds = create_translation_dataset("openai-translation-example")
-    if translation_ds:
-        published_version = publish_dataset_example(translation_ds)
-        if published_version:
-            get_dataset_by_version_example(
-                slug="openai-translation-example", version=published_version
-            )
-        delete_dataset_example(translation_ds.slug)
+    try:
+        # Translation Dataset
+        translation_ds = create_translation_dataset("openai-translation-example")
+        if translation_ds:
+            published_version = publish_dataset_example(translation_ds)
+            if published_version:
+                get_dataset_by_version_example(
+                    slug="openai-translation-example", version=published_version
+                )
+            delete_dataset_example(translation_ds.slug)
+    except Exception as e:
+        print(f"Error in OpenAI translation example: {e}")
 
     print("\n" + "=" * 50)
     print("All examples completed!")

packages/sample-app/sample_app/dataset_example.py (2)

339-345: Fix multiline string indentation in fallback response

The multiline string has incorrect indentation that will be preserved in the output, making the response look unprofessional.

Fix the indentation of the multiline string:

                 data.append(
                     {
                         "customer_query": query,
-                        "ai_response": """I apologize, but I'm unable to process your request at the moment.
-                            Please contact our support team directly.""",
+                        "ai_response": "I apologize, but I'm unable to process your request at the moment. Please contact our support team directly.",
                         "timestamp": datetime.now().isoformat(),
                         "query_category": "general_support",
                         "resolved": False,
                     }
                 )

---

392-395: Fix multiline string formatting in system prompt

The multiline string in the system content has inconsistent formatting that may affect the AI's understanding of the prompt.

Clean up the system prompt formatting:

                         messages=[
                             {
                                 "role": "system",
-                                "content": f"""You are a professional translator.
-                                Translate the following English text to {lang}.
-                                Provide only the translation.""",
+                                "content": f"You are a professional translator. Translate the following English text to {lang}. Provide only the translation.",
                             },
                             {"role": "user", "content": phrase},
                         ],

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro