Troubleshoot issues writing data

• Handle write and delete responses
• Troubleshoot failures
• Troubleshoot rejected points

In InfluxDB Cloud, writes and deletes are asynchronous and eventually consistent. Once InfluxDB validates your request and queues the write or delete, it sends a success response (HTTP 204 status code) as an acknowledgement. To ensure that InfluxDB handles writes and deletes in the order you request them, wait for the acknowledgement before you send the next request. Because writes are asynchronous, keep the following in mind:

• Data might not yet be queryable when you receive success (HTTP 204 status code).
• InfluxDB may still reject points after you receive success (HTTP 204 status code).

Troubleshoot partial writes

Because writes are asynchronous, they may fail partially or completely even though InfluxDB returns an HTTP 2xx status code for a valid request. For example, a partial write may occur when InfluxDB writes all points that conform to the bucket schema, but rejects points that have the wrong data type in a field. To check for writes that fail asynchronously, create a task to check the _monitoring bucket for rejected points. To resolve partial writes and rejected points, see troubleshoot failures.

• Check the message property in the response body for details about the error–for example, partial write error indicates rejected points.
• Check for rejected points in your organization’s _monitoring bucket.
• Verify all lines contain valid syntax (line protocol or CSV). See how to find parsing errors.
• Verify the data types match the series or bucket schema. See how to resolve explicit schema rejections.
• Verify the timestamps match the precision parameter.
• Minimize payload size and network errors by optimizing writes.

InfluxDB may have rejected points even if the HTTP request returned “Success”. InfluxDB logs rejected data points and associated errors to your organization’s _monitoring bucket.

• Review rejected points
  • Find parsing errors
  • Find data type conflicts and schema rejections
• Resolve data type conflicts
• Resolve explicit schema rejections

Review rejected points

To get a log of rejected points, query the rejected_points measurement in your organization’s _monitoring bucket. To more quickly locate rejected_points, keep the following in mind:

• If your line protocol batch contains single lines with multiple fields, InfluxDB logs an entry for each point (each unique field) that is rejected.
• Each entry contains a reason tag that describes why the point was rejected.
• Entries for data type conflicts and schema rejections have a count field value of 1.
• Entries for parsing errors contain an error field (and don’t contain a count field).

rejected_points schema

Find parsing errors

If InfluxDB can’t parse a line (e.g. due to syntax problems), the response message might not provide details. To find parsing error details, query rejected_points entries that contain the error field.

from(bucket: "_monitoring")
    |> range(start: -1h)
    |> filter(fn: (r) => r._measurement == "rejected_points")
    |> filter(fn: (r) => r._field == "error")

Find data type conflicts and schema rejections

To find rejected_points caused by data type conflicts or schema rejections, query for the count field.

from(bucket: "_monitoring")
    |> range(start: -1h)
    |> filter(fn: (r) => r._measurement == "rejected_points")
    |> filter(fn: (r) => r._field == "count")

Resolve data type conflicts

When you write to a bucket that has the implicit schema type, InfluxDB compares new points to points that have the same series. If a point has a field with a different data type than the series, InfluxDB rejects the point and logs a rejected_points entry. The rejected_points entry contains one of the following reasons:

Resolve explicit schema rejections

If you write to a bucket with an explicit schema, the data must conform to the schema. Otherwise, InfluxDB rejects the data.

Do the following to interpret explicit schema rejections:

• Detect a measurement mismatch
• Detect a field type mismatch

Detect a measurement mismatch

InfluxDB rejects a point if the measurement doesn’t match the name of a bucket schema. The rejected_points entry contains the following reason tag value:

Consider the following line protocol data.

airSensors,sensorId=TLM0201 temperature=73.97,humidity=35.23,co=0.48 1637014074

The line has an airSensors measurement and three fields (temperature, humidity, and co). If you try to write this data to a bucket that has the explicit schema type and doesn’t have an airSensors schema, the /api/v2/write InfluxDB API returns an error and the following data:

{
  "code": "invalid",
  "message": "3 out of 3 points rejected (check rejected_points in your _monitoring bucket for further information)"
}

InfluxDB logs three rejected_points entries, one for each field.

Detect a field type mismatch

InfluxDB rejects a point if the measurement matches the name of a bucket schema and the field data types don’t match. The rejected_points entry contains the following reason:

Consider a bucket that has the following airSensors explicit bucket schema:

{
 "name": "airSensors",
 "columns": [
   {
     "name": "time",
     "type": "timestamp"
   },
   {
     "name": "sensorId",
     "type": "tag"
   },
   {
     "name": "temperature",
     "type": "field",
     "dataType": "float"
   },
   {
     "name": "humidity",
     "type": "field",
     "dataType": "float"
   },
   {
     "name": "co",
     "type": "field",
     "dataType": "float"
   }
 ]
}

The following line protocol data has an airSensors measurement, a sensorId tag, and three fields (temperature, humidity, and co).

airSensors,sensorId=L1 temperature=90.5,humidity=70.0,co=0.2 1637014074
airSensors,sensorId=L1 temperature="90.5",humidity=70.0,co=0.2 1637014074

In the example data above, the second point has a temperature field value with the string data type. Because the airSensors schema requires temperature to have the float data type, InfluxDB returns a 400 error and a message that describes the result:

{
  "code": "invalid",
  "message": "partial write error (5 accepted): 1 out of 6 points rejected (check rejected_points in your _monitoring bucket for further information)"
}

InfluxDB logs the following rejected_points entry to the _monitoring bucket: