Como devo armazenar séries temporais no mongodb

Preciso criar um banco de dados de séries temporais e executar as seguintes tarefas:

• criar novas séries temporais
• atualizar séries temporais existentes
• consultar uma ou várias séries temporais ao mesmo tempo (por exemplo, todas as séries temporais para a mesma data, etc ...)

O Mongo está adaptado a isso e, se sim, como devo estruturar o banco de dados? (uma série temporal = um documento? Ou um documento = uma entrada da série temporal, e todos esses documentos formam a coleção, que é a série temporal inteira?)

Estou um pouco perdido aqui e acho difícil encontrar qualquer informação, pois geralmente o Mongo é apresentado como muito flexível, para que o usuário possa escolher a infraestrutura.

Qualquer link para o tutorial que explique especificamente como gerenciar séries temporais no Mongo é muito bem-vindo.

Obrigado!

Sugiro uma única entrada de série temporal por documento. Existem alguns problemas com o armazenamento de várias entradas por documento:

• um único documento está limitado a um determinado tamanho (atualmente 16 MB); isso limita quantas entradas podem ser armazenadas em um único documento
• À medida que mais entradas são adicionadas a um documento, o documento inteiro (e a série temporal) serão desnecessariamente excluídos e realocados para um pedaço maior de memória
• consultas em sub-documentos são limitadas em comparação com consultas em documentos regulares
• documentos com estruturas muito planas (como um sub-documento por cada segundo) não têm bom desempenho
• o redutor de mapa incorporado não funciona tão bem em sub-documentos

Observe também que um carimbo de data / hora está embutido no MongoDB ObjectId padrão . Você pode usar isso se a precisão da série temporal for inferior a um segundo.

Aqui está um exemplo de documento BSON de uma biblioteca de log de eventos que usa o MongoDB :

Example format of generated bson document:
{
    'thread': -1216977216,
    'level': 'ERROR',
    'timestamp': Timestamp(1290895671, 63),
    'message': 'test message',
    'fileName': '/var/projects/python/log4mongo-python/tests/test_mongo_handler.py',
    'lineNumber': 38,
    'method': 'test_emit_exception',
    'loggerName':  'testLogger',
    'exception': {
        'stackTrace': 'Traceback (most recent call last):
                       File "/var/projects/python/log4mongo-python/tests/test_mongo_handler.py", line 36, in test_emit_exception
                       raise Exception(\'exc1\')
                       Exception: exc1',
        'message': 'exc1',
        'code': 0
    }
}

Como um log de eventos é semelhante a uma série temporal, pode valer a pena estudar o restante do código . Existem versões em Java, C #, PHP e Python.

Aqui está outro projeto semelhante de código aberto: Zarkov

[update] Em resposta ao comentário do @ RockScience, adicionei mais algumas referências:

• Estudo de caso muito detalhado de como o MongoDB foi usado para armazenar séries temporais . Peças interessantes:
  • Slide 25: quantos dados? 20 pontos de dados de 4 bytes a intervalos de 1 minuto por 10 anos (não é aparente se essas são estatísticas reais ou apenas estimativas projetadas)
  • Slide 66: mostra um exemplo de documento do MongoDB usado para armazenar dados de séries temporais
• Práticas recomendadas para armazenar dados de log , diretamente dos criadores do MongoDB

Encontrei essa pergunta no SO ( /programming/4814167/storing-time-series-data-relational-or-non ), onde o OP pergunta como armazenar uma série temporal. Embora a pergunta dele seja mais baseada no uso de um banco de dados NoSQL ou RDBMS, e você parece bem decidido em usar um banco de dados NoSQL.

Também encontrou este artigo em " Os requisitos exclusivos do banco de dados de dados de séries temporais " que podem ser úteis.

Espero que isto ajude.

Sim, definitivamente, o banco de dados NoSQL é mais adequado para armazenar dados de séries temporais do que o RDBMS tradicional.

Sim O MongoDB está excepcionalmente adaptado a este caso de uso.

-Como você deve estruturar o banco de dados? Um documento = uma entrada de série temporal VS várias séries temporais.

A resposta é armazenar em um documento várias séries temporais. Ter menos documentos ajudará o desempenho com menos leituras. Um truque é preparar seu documento com os valores predefinidos. Isso otimizará a atualização do documento, evitando o preenchimento de registros .

Aqui está um exemplo de esquema sobre como armazenar idealmente uma hora no valor de séries temporais com um intervalo de minutos:

{
  timestamp_hour: ISODate("2015-07-02T23:00:00.000Z"),
  type: “memory_used”,
  values: {
    0: 999999,
    1: 1000000, 
    …,
    58: 0,
    59: 0
  }
}

Você o inicia com 0 valores e as atualizações serão otimizadas. As leituras são otimizadas porque um documento é lido em vez de 60. Se você precisar armazenar um dia de dados ou um mês em que prosseguir com a mesma técnica, terá uma idéia.

Aqui está o link para um tutorial que explica especificamente como gerenciar séries cronológicas no MongoDb a partir do Blog oficial do MongoDb: http://blog.mongodb.org/post/65517193370/schema-design-for-time-series-data-in- mongodb