Elastic MongoDB connector reference

The Elastic MongoDB connector is a connector for MongoDB data sources.

This connector is available as a native connector in Elastic versions 8.5.0 and later. To use this connector as a native connector, satisfy all native connector requirements.

This connector is also available as a connector client from the Ruby connectors framework. To use this connector as a connector client, satisfy all connector client requirements.

This connector has no additional prerequisites beyond the shared requirements, linked above.

This connector is available in technical preview. Features in technical preview are subject to change and are not covered by the service level agreement (SLA) of features that have reached general availability (GA).

To use this connector as a native connector, use the use a connector workflow. See Native connectors.

To use this connector as a connector client, use the build a connector workflow. See Connector clients and frameworks.

For additional operations, see Usage.

An example is available for this connector. See MongoDB connector tutorial.

It’s not possible to use expressions like new Date() inside an aggregation pipeline. These expressions won’t be evaluated by the underlying MongoDB client, but will be passed as a string to the MongoDB instance. A possible workaround is to use aggregation variables.

Incorrect (new Date() will be interpreted as string):

{
    "aggregate": {
        "pipeline": [
            {
                "$match": {
                  "expiresAt": {
                    "$gte": "new Date()"
                  }
                }
            }
        ]
    }
}

Correct (usage of $$NOW):

{
  "aggregate": {
    "pipeline": [
      {
        "$addFields": {
          "current_date": {
            "$toDate": "$$NOW"
          }
        }
      },
      {
        "$match": {
          "$expr": {
            "$gte": [
              "$expiresAt",
              "$current_date"
            ]
          }
        }
      }
    ]
  }
}

See Known issues for any issues affecting all connectors.

See Troubleshooting.

See Security.

This connector is compatible with MongoDB Atlas and MongoDB 3.6 and later.

The data source and your Elastic deployment must be able to communicate with each other over a network.

Each time you create an index to be managed by this connector, you will create a new connector configuration. You will need some or all of the following information about the data source.

The following describes the default syncing behavior for this connector. Use sync rules and ingest pipelines to customize syncing for specific indices.

All documents in the configured MongoDB database and collection are extracted and transformed into documents in your Elasticsearch index.

This results in Elasticsearch documents that closely match the original MongoDB documents.

The Elasticsearch mapping is created when the first document is created.

Each sync is a "full" sync. For each MongoDB document discovered:

This is recursive, because embedded documents can themselves contain embedded documents.

The following sections describe Sync rules for this connector.

A single basic rule translates quite cleanly to a mongodb find query. For example, a single rule like:

Will translate to a mongodb find query of:

{
  "bedrooms" : {
    "$gte" : 4.0
  }
}

The connector makes a best effort to convert the "value" of the rule to the appropriate type. For example, true would be coerced into a boolean, and 1234 would be coerced into an integer. This may cause issues for fields that have mixed types, or unconventional representations.

Multiple basic sync rules are combined with an AND clause, and are executed in a find query. So for example, if we have the following rules:

This would result in a following mongodb find query:

{
  "$and":[
  {"state": "MA"},
  {"ID": {"$lte": 1000}}
 ]
}

Advanced rules for MongoDB can be used to express either find queries or aggregation pipelines. They can also be used to tune options available when issuing these queries/pipelines.

For find queries, the structure of this JSON DSL should look like:

{
	"find":{
		"filter": {
			// find query goes here
		},
		"options":{
			// query options go here
		}
	}
}

For example:

{
	"find":{
		"filter": {
			"$text": {
				"$search" : "garden",
				"$caseSensitive" : false
			}
		},
		"options":{
			"skip" : 10,
			"limit" : 1000
		}
	}
}

Where the available options are:

Similarly, for aggregation pipelines, the structure of the JSON DSL should look like:

{
	"aggregate":{
		"pipeline": [
			// pipeline elements go here
		],
		"options": {
            // pipeline options go here
		}
    }
}

Where the available options are:

This connector is included in the Ruby connectors framework.

View the source code for this connector (branch 8.6, compatible with Elastic 8.6).