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

Availability and prerequisitesedit

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).

Usageedit

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.

Exampleedit

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

Known issuesedit

Expressions and variables in aggregation pipelinesedit

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.

Troubleshootingedit

See Troubleshooting.

Securityedit

See Security.

Compatibilityedit

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.

Configurationedit

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.

Documents and syncsedit

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.

Sync rulesedit

The following sections describe Sync rules for this connector.

Basic rulesedit

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 rulesedit

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.

find queriesedit

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:

Aggregation pipelinesedit

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:

Framework and sourceedit

This connector is included in the Ruby connectors framework.

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