Monstermq Graphql Data

query GetRetainedMessages($filter: String) {
  retainedMessages(topicFilter: $filter, format: JSON, limit: 100) {
    topic
    payload
    timestamp
    qos
  }
}

query GetArchivedMessages(
  $topicFilter: String!,
  $archiveGroup: String = "Default",
  $startTime: String,
  $endTime: String,
  $limit: Int = 100
) {
  archivedMessages(
    topicFilter: $topicFilter,
    archiveGroup: $archiveGroup,
    startTime: $startTime,
    endTime: $endTime,
    format: JSON,
    limit: $limit
  ) {
    topic
    payload
    timestamp
    qos
  }
}

query GetAggregatedMessages(
  $topics: [String!]!,
  $archiveGroup: String = "Default",
  $interval: AggregationInterval!,
  $startTime: String!,
  $endTime: String!
) {
  aggregatedMessages(
    topics: $topics,
    archiveGroup: $archiveGroup,
    interval: $interval,
    startTime: $startTime,
    endTime: $endTime,
    functions: [AVG, MAX, MIN],
    fields: ["value"]
  ) {
    timestamps
    topics {
      topic
      field
      function
      values
    }
  }
}

query GetSessions($connected: Boolean, $clientIdFilter: String) {
  sessions(connected: $connected, clientId: $clientIdFilter) {
    clientId
    nodeId
    connected
    cleanSession
    subscriptions {
      topicFilter
      qos
    }
    metrics {
      messagesIn
      messagesOut
    }
  }
}

query GetSingleSession($clientId: String!) {
  session(clientId: $clientId) {
    clientId
    nodeId
    connected
    cleanSession
    keepAlive
    lastConnectedTime
  }
}

query GetSystemLogs($lastMinutes: Int, $level: [String!], $message: String) {
  systemLogs(
    lastMinutes: $lastMinutes,
    level: $level,
    message: $message,
    limit: 50,
    orderByTime: DESC
  ) {
    timestamp
    level
    logger
    message
    node
    sourceClass
    sourceMethod
  }
}

query GetDeviceConfigs {
  opcUaClientConfigs {
    name
    endpointUrl
    enabled
    nodeId
    connectState
    subscriptions {
      nodeId
      mqttTopic
    }
  }
  plc4xClientConfigs {
    name
    connectionString
    enabled
    connectState
  }
}

# Browse OPC UA address space
query BrowseOpcUaNode($name: String!, $nodePath: String) {
  opcUaBrowse(name: $name, nodePath: $nodePath) {
    nodeId
    displayName
    browseName
    nodeClass
    hasChildren
  }
}

# Read OPC UA tag value directly
query ReadOpcUaNode($name: String!, $nodePath: String!) {
  opcUaRead(name: $name, nodePath: $nodePath) {
    value
    statusCode
    serverTimestamp
  }
}

query GetFlows {
  flowClasses {
    name
    namespace
    version
    description
  }
  flowInstances {
    name
    flowClassId
    nodeId
    enabled
    status {
      running
      lastExecution
      executionCount
      errorCount
      lastError
    }
  }
}

query GetAgents {
  agents {
    name
    namespace
    nodeId
    enabled
    provider
    model
    inputTopics
    outputTopics
  }
}

query GetTopicSchemas {
  topicSchemas {
    topicFilter
    jsonSchema
    description
  }
}

subscription OnTopicUpdates($filters: [String!]!) {
  topicUpdates(topicFilters: $filters, format: JSON) {
    topic
    payload
    format
    timestamp
    qos
    retained
    clientId
  }
}

subscription OnTopicUpdatesBulk($filters: [String!]!) {
  topicUpdatesBulk(topicFilters: $filters, format: JSON, timeoutMs: 500, maxSize: 50) {
    count
    timestamp
    updates {
      topic
      payload
      timestamp
    }
  }
}

subscription OnSystemLogs($level: [String!]) {
  systemLogs(level: $level) {
    timestamp
    level
    logger
    message
    node
  }
}

import requests

GRAPHQL_URL = "http://localhost:4000/graphql"
headers = {"Content-Type": "application/json"}

# Step 1: Discover available Archive Groups & match target topic filter
archive_query = """
query DiscoverArchives {
  archiveGroups(enabled: true) {
    name
    topicFilter
    archiveType
    lastValType
  }
}
"""
res = requests.post(GRAPHQL_URL, json={"query": archive_query}, headers=headers).json()
groups = res["data"]["archiveGroups"]
print("Available Archive Groups:")
for g in groups:
    print(f" - Group: {g['name']} | Filters: {g['topicFilter']} | Store: {g['archiveType']}")

# Assume target topic "opcua/plc1/temperature" matches group "Industrial"
target_group = "Industrial"

# Step 2: Query historical messages specifying the discovered archive group
history_query = """
query GetHistory($topicFilter: String!, $archiveGroup: String!) {
  archivedMessages(
    topicFilter: $topicFilter,
    archiveGroup: $archiveGroup,
    limit: 50
  ) {
    topic
    payload
    timestamp
  }
}
"""
params = {
    "topicFilter": "opcua/plc1/temperature",
    "archiveGroup": target_group
}

history_res = requests.post(GRAPHQL_URL, json={"query": history_query, "variables": params}, headers=headers).json()
print("Historical Messages:", history_res["data"]["archivedMessages"])

curl -X POST http://localhost:4000/graphql \
  -H "Content-Type: application/json" \
  -d '{
    "query": "query GetHistory($filter: String!, $group: String!) { archivedMessages(topicFilter: $filter, archiveGroup: $group, limit: 10) { topic payload timestamp } }",
    "variables": {
      "filter": "telemetry/#",
      "group": "Industrial"
    }
  }'