How to fix StrictDynamicMappingException: mapping set to strict, dynamic introduction of [field] within [type] is not allowed in Elasticsearch

# Get the mapping for a specific index
curl -X GET "localhost:9200/my-index/_mapping" -u "username:password"

# Get mapping for all indices
curl -X GET "localhost:9200/_mapping" -u "username:password"

# Check the dynamic setting in the mapping
curl -X GET "localhost:9200/my-index/_mapping/field/dynamic" -u "username:password"

# Example response showing strict mapping:
# {
#   "my-index": {
#     "mappings": {
#       "dynamic": "strict",
#       "properties": {
#         "title": { "type": "text" },
#         "timestamp": { "type": "date" }
#         // Only these fields are allowed
#       }
#     }
#   }
# }

# Check Elasticsearch logs for the exact error
tail -f /var/log/elasticsearch/elasticsearch.log | grep StrictDynamicMappingException

# If using the Elasticsearch REST API, the error response includes the field name:
# {
#   "error": {
#     "type": "strict_dynamic_mapping_exception",
#     "reason": "mapping set to strict, dynamic introduction of [new_field] within [my-type] is not allowed"
#   }
# }

# For bulk operations, check individual failures
curl -X POST "localhost:9200/_bulk" -u "username:password" -H 'Content-Type: application/json' -d'
{ "index" : { "_index" : "my-index", "_id" : "1" } }
{ "title": "Test", "new_field": "value", "timestamp": "2024-01-01" }
{ "index" : { "_index" : "my-index", "_id" : "2" } }
{ "title": "Test 2", "timestamp": "2024-01-02" }
'

# The response will show which document failed and why

# Update mapping to allow dynamic fields (not recommended for production)
curl -X PUT "localhost:9200/my-index/_mapping" -u "username:password" -H 'Content-Type: application/json' -d'
{
  "dynamic": true
}
'

# Or set to "false" to ignore unknown fields (they won't be indexed)
curl -X PUT "localhost:9200/my-index/_mapping" -u "username:password" -H 'Content-Type: application/json' -d'
{
  "dynamic": false
}
'

# For multiple indices
curl -X PUT "localhost:9200/my-index-*/_mapping" -u "username:password" -H 'Content-Type: application/json' -d'
{
  "dynamic": true
}
'

# Note: You may need to close and reopen the index for mapping changes
curl -X POST "localhost:9200/my-index/_close" -u "username:password"
curl -X PUT "localhost:9200/my-index/_mapping" -u "username:password" -H 'Content-Type: application/json' -d'
{
  "dynamic": true
}
'
curl -X POST "localhost:9200/my-index/_open" -u "username:password"

# Update mapping with all required fields
curl -X PUT "localhost:9200/my-index/_mapping" -u "username:password" -H 'Content-Type: application/json' -d'
{
  "dynamic": "strict",
  "properties": {
    "title": {
      "type": "text",
      "fields": {
        "keyword": {
          "type": "keyword",
          "ignore_above": 256
        }
      }
    },
    "timestamp": {
      "type": "date"
    },
    "new_field": {
      "type": "keyword"  # Add the previously missing field
    },
    "another_field": {
      "type": "integer"
    },
    "nested_object": {
      "type": "nested",
      "properties": {
        "subfield": { "type": "text" }
      }
    }
  }
}
'

# Use index templates for consistent mappings across indices
curl -X PUT "localhost:9200/_index_template/my-template" -u "username:password" -H 'Content-Type: application/json' -d'
{
  "index_patterns": ["logs-*"],
  "template": {
    "mappings": {
      "dynamic": "strict",
      "properties": {
        "@timestamp": { "type": "date" },
        "message": { "type": "text" },
        "level": { "type": "keyword" },
        "service": { "type": "keyword" }
      }
    }
  },
  "priority": 200
}
'

// Example: Validate documents against expected schema
const { Client } = require('@elastic/elasticsearch');
const client = new Client({ node: 'http://localhost:9200' });

// Define your expected schema
const expectedSchema = {
  title: 'string',
  timestamp: 'date',
  new_field: 'string',
  count: 'number'
};

function validateDocument(doc, schema) {
  const errors = [];

  // Check for missing required fields
  Object.keys(schema).forEach(field => {
    if (!(field in doc)) {
      errors.push("Missing required field: " + field);
    }
  });

  // Check for unexpected fields
  Object.keys(doc).forEach(field => {
    if (!(field in schema)) {
      errors.push("Unexpected field: " + field);
    }
  });

  return errors;
}

async function safeIndexDocument(indexName, document) {
  const validationErrors = validateDocument(document, expectedSchema);

  if (validationErrors.length > 0) {
    console.error('Document validation failed:', validationErrors);
    throw new Error('Invalid document: ' + validationErrors.join(', '));
  }

  try {
    const response = await client.index({
      index: indexName,
      body: document
    });
    return response;
  } catch (error) {
    if (error.meta?.body?.error?.type === 'strict_dynamic_mapping_exception') {
      console.error('Strict mapping violation. Update your schema definition.');
      // Log the problematic field for debugging
      const fieldMatch = error.meta.body.error.reason.match(/[([^]]+)]/);
      if (fieldMatch) {
        console.error('Field "' + fieldMatch[1] + '" needs to be added to the mapping.');
      }
    }
    throw error;
  }
}

// Example usage
await safeIndexDocument('my-index', {
  title: 'Test Document',
  timestamp: new Date().toISOString(),
  new_field: 'test value',
  count: 42
});

# Create mapping with dynamic templates
curl -X PUT "localhost:9200/my-index/_mapping" -u "username:password" -H 'Content-Type: application/json' -d'
{
  "dynamic_templates": [
    {
      "strings_as_keywords": {
        "match_mapping_type": "string",
        "mapping": {
          "type": "keyword"
        }
      }
    },
    {
      "metrics_as_doubles": {
        "match": "metric_*",
        "mapping": {
          "type": "double"
        }
      }
    },
    {
      "tags_as_keywords": {
        "match": "*_tag",
        "mapping": {
          "type": "keyword"
        }
      }
    }
  ],
  "properties": {
    "title": { "type": "text" },
    "timestamp": { "type": "date" }
  }
}
'

# Dynamic templates allow:
# - All string fields to be indexed as keywords
# - Fields starting with "metric_" to be doubles
# - Fields ending with "_tag" to be keywords
# - Other fields will be rejected (strict mode still applies)

# You can also combine with "dynamic": true but limit field count
curl -X PUT "localhost:9200/my-index/_settings" -u "username:password" -H 'Content-Type: application/json' -d'
{
  "index.mapping.total_fields.limit": 1000,
  "index.mapping.depth.limit": 20,
  "index.mapping.nested_fields.limit": 50
}
'