Perguntas[jq](coding)

Tenho alguns dados parecidos com estes:

{
"data": [
    {
      "startTime": "2024-12-31T00:00:00Z",
      "data": [
        {
          "one": "a",
          "two": 1125.000
        },
        {
          "one": "b",
          "two": 2119.000
        },
        {
          "one": "c",
          "two": 0.000
        }
      ]
    },

com vários objetos no array de dados externo. O que estou falhando é em produzir algo como isto:

startTime, one, two

que no caso dos dados acima me daria três linhas de saída. Eu posso obter um e dois juntos, mas não startTime: comjq -r '.data[] | "\(.startTime)", (.data[] | "\(.one), \(.two)" )'

2024-12-31T00:00:00Z
a, 1125.000
b, 2119.000
c, 0.000

jq -r '.data[] | "\(.startTime)", (.data[] | "\(.one), \(.two)" )'me dá o seguinte, iterando sobre cada um dos últimos itens ("dois"):

2024-12-31T00:00:00Z, a, 1125.000
2024-12-31T00:00:00Z, b, 1125.000
2024-12-31T00:00:00Z, c, 1125.000
2024-12-31T00:00:00Z, a, 2119.000
2024-12-31T00:00:00Z, b, 2119.000
2024-12-31T00:00:00Z, c, 2119.000
2024-12-31T00:00:00Z, a, 0.000
2024-12-31T00:00:00Z, b, 0.000
2024-12-31T00:00:00Z, c, 0.000

Não consigo encontrar a sintaxe correta.

No script jq abaixo, quero imprimir a concatenação de e first_nameou last_nameapenas last_name.

$ echo '{"first_name": "John", "last_name": "Johnson"}' | jq -c '{
  "name": (if (.last_name | startswith(.first_name)) 
           then .last_name 
           else .first_name + " " + .last_name 
           end)
}'

O erro é

jq: error (at <stdin>:1): Cannot index string with string "first_name"

O comando jq falha na chamada para startswith- como se startswithaceitasse apenas literais de string. Se eu mudar startswith(.first_name)para startswith("John")então a expressão compila e funciona como esperado.

No exemplo do mundo real, há muitos registros de entrada e muitos first_names diferentes. Existe uma maneira de eu conectar .first_nameem startswith?

Dada a entrada simplificada:

[
  [ "gpu" ],
  [ "disk" ]
]

Gostaria de selecionar as matrizes cujo primeiro elemento é "gpu".

Posso fazer isso com uma condição simples:

map(select(.[0] == "gpu"))

[
  [ "gpu" ]
]

Mas não entendo o que há de errado quando tento usar o INbuiltin:

map(select(.[0] | IN(["gpu"])))

[]

Estou usando jq1.6

Tenho o seguinte JSON (com base na saída NDPI)

{
    "src_ip": "x.x.x.x",
    "dest_ip": "x1.x1.x1.x1",
    "src_port": 48318,
    "dst_port": 443,
    "ip": 4,
    "proto": "TCP",
    "ndpi": {
        "flow_risk": {
            "35": {
                "risk": "Susp Entropy",
                "severity": "Medium",
                "risk_score": {
                    "total": 210,
                    "client": 165,
                    "server": 45
                }
            }
        },
        "confidence": {
            "1": "Match by port"
        },
        "proto": "TLS",
        "proto_id": "91",
        "proto_by_ip": "Unknown",
        "proto_by_ip_id": 0,
        "encrypted": 1,
        "breed": "Safe",
        "category_id": 5,
        "category": "Web"
    },
    "detection_completed": 1,
    "check_extra_packets": 0,
    "flow_id": 0,
    "first_seen": 1733074272.824,
    "last_seen": 1733074282.757,
    "duration": 9.933,
    "vlan_id": 0,
    "bidirectional": 1,
    "xfer": {
        "data_ratio": -0.958,
        "data_ratio_str": "Download",
        "src2dst_packets": 1268,
        "src2dst_bytes": 86239,
        "src2dst_goodput_bytes": 2551,
        "dst2src_packets": 2693,
        "dst2src_bytes": 4042956,
        "dst2src_goodput_bytes": 3865218
    },
    "iat": {
        "flow_min": 1,
        "flow_avg": 6.1,
        "flow_max": 4005,
        "flow_stddev": 108.3,
        "c_to_s_min": 0,
        "c_to_s_avg": 7.4,
        "c_to_s_max": 4005,
        "c_to_s_stddev": 137.8,
        "s_to_c_min": 0,
        "s_to_c_avg": 1.4,
        "s_to_c_max": 35,
        "s_to_c_stddev": 2.2
    },
    "pktlen": {
        "c_to_s_min": 66,
        "c_to_s_avg": 68.0,
        "c_to_s_max": 514,
        "c_to_s_stddev": 28.8,
        "s_to_c_min": 66,
        "s_to_c_avg": 1501.3,
        "s_to_c_max": 1506,
        "s_to_c_stddev": 76.6
    },
    "tcp_flags": {
        "cwr_count": 0,
        "ece_count": 0,
        "urg_count": 0,
        "ack_count": 3961,
        "psh_count": 1323,
        "rst_count": 0,
        "syn_count": 0,
        "fin_count": 0,
        "src2dst_cwr_count": 0,
        "src2dst_ece_count": 0,
        "src2dst_urg_count": 0,
        "src2dst_ack_count": 1268,
        "src2dst_psh_count": 7,
        "src2dst_rst_count": 0,
        "src2dst_syn_count": 0,
        "src2dst_fin_count": 0,
        "dst2src_cwr_count": 0,
        "dst2src_ece_count": 0,
        "dst2src_urg_count": 0,
        "dst2src_ack_count": 2693,
        "dst2src_psh_count": 1316,
        "dst2src_rst_count": 0,
        "dst2src_syn_count": 0,
        "dst2src_fin_count": 0
    },
    "c_to_s_init_win": 0,
    "s_to_c_init_win": 0
}

Posso obter quase todas as informações (src_ip, portas, etc.), mas há uma coisa relacionada ao "flow_risk"

{"flow_risk": {"35": {"risk":"Susp Entropy","severity":"Medium"

que está relacionado ao número (neste caso 35). Este número pode ser diferente (de 01 a 50) e não sei como filtrar para buscar números diferentes.

No momento, esse é o filtro que estou usando

cat data.json | jq -r '"\(.src_ip),\(.src_port),\(.dest_ip),\(.dst_port),\(.proto),\(.ndpi.proto),\(.ndpi.category),\(.ndpi.hostname),\(.duration),\(.vlan_id),\(.xfer.src2dst_bytes),\(.xfer.dst2src_bytes),\(.ndpi.flow_risk."35".risk),\(.ndpi.flow_risk."35".severity)"')

Isso funciona quando o número é exatamente 35, mas há alguma chance de usar algo como curingas com jQ?

Quero dizer, como posso fazer isso para aceitar vários números? (por exemplo: pesquisar de 01 a 50?)

Algo como

\(.ndpi.flow_risk."*".risk),\(.ndpi.flow_risk."*".severity)"')

obrigado !

Com um campo Json como o abaixo, se eventId for um valor contínuo, gostaria de adicionar o valor do campo de mensagem.

Entretanto, mesmo que eventId seja contínuo, se o campo de mensagem começar com # Hora, o campo de mensagem será separado.

Este é o campo original do Json.

{
    "events": [
        {
            "message": "# Time: 1",
            "eventId": "38636469249093328935961608873790523617989208925384015872"
        },
        {
            "message": ", 2, 3",
            "eventId": "38636469249093328935961608873790523617989208925384015873"
        },
        {
            "message": "# Time: 11",
            "eventId": "38636469249093328935961608873790523617989208925384015875"
        },
        {
            "message": "# Time: 12",
            "eventId": "38636469249093328935961608873790523617989208925384015876"
        },
        {
            "message": "# Time: A",
            "eventId": "1"
        },
        {
            "message": ", B, C",
            "eventId": "2"
        },
        {
            "message": "# Time: C",
            "eventId": "3"
        },
        {
            "message": "# Time: D",
            "eventId": "5"
        }
    ]
}

[
  {
    "message": "# Time: 1, 2, 3"
  },
  {
    "message": "# Time: 11"
  },
  {
    "message": "# Time: 12"
  },
  {
    "message": "# Time: A , B, C"
  },
  {
    "message": "# Time: C"
  },
  {
    "message": "# Time: D"
  }
]

Já fiz uma pergunta sobre isso antes e recebi uma resposta de uma ótima pessoa. (Obrigado pmf.)
Depois disso, tentei o meu melhor para refinar um pouco mais, mas não funcionou, então perguntei mais uma vez.

Primeiro, quando executei este JQ pela primeira vez, obtive os seguintes resultados.

jq -r '.events 
| reduce .[1:][] as $i (.[:1];
    if ((.[-1].eventId | tonumber + 1 | tostring) != $i.eventId) or ($i.message | startswith("# Time:")) then
        . += [$i]
    else
        .[-1].message += " " + $i.message
    end
) 
| del(.[].eventId)
'

[
  {
    "message": "# Time: 1"
  },
  {
    "message": ", 2, 3"
  },
  {
    "message": "# Time: 11"
  },
  {
    "message": "# Time: 12"
  },
  {
    "message": "# Time: A , B, C"
  },
  {
    "message": "# Time: C"
  },
  {
    "message": "# Time: D"
  }
]

jq '
# Function to add one to a large number represented as a string
def add_one(num):
  (num | split("") | reverse | map(tonumber)) as $digits
  | reduce range(0; length) as $i ([];
      . + if $i == 0 or .[-1] == 10 then
            [($digits[$i] + 1) % 10]
         else
            [$digits[$i]]
         end
    )
  | reverse | map(tostring) | join("");

# Process events and check continuity
.events 
| map(.eventId |= tostring) # Ensure all eventIds are strings
| reduce .[1:][] as $i (.[:1];
    if (add_one(.[-1].eventId) != $i.eventId) or ($i.message | startswith("# Time:")) then
        . += [$i]
    else
        .[-1].message += " " + $i.message
    end
)
| del(.[].eventId)
'

[
  {
    "message": "# Time: 1"
  },
  {
    "message": ", 2, 3"
  },
  {
    "message": "# Time: 11"
  },
  {
    "message": "# Time: 12"
  },
  {
    "message": "# Time: A"
  },
  {
    "message": ", B, C"
  },
  {
    "message": "# Time: C"
  },
  {
    "message": "# Time: D"
  }
]

Pesquisando mais, encontrei um comando chamado gojq, mas gostaria de testá-lo primeiro para ver se é possível com jq.

Estou usando o jq versão 1.7.1.

Estou tentando comparar dois arquivos json longos com o WinMerge usando o plugin QueryJSON. As propriedades nesses arquivos estão em ordem aleatória. Esse parâmetro para .\jq funciona, mas objetos aninhados não são afetados:

QueryJSON ". | to_entries | sort_by(.key) | from_entries"

Há um comando "flatten" que não me forneceu o resultado que procurei (pode estar sendo usado incorretamente).

Jsons poderiam ser, por exemplo:

{
   "Id": 1,
   "Addresses":[
      {"Street": "Street 1",
      "PostalCode": 12345},
      {"Street": "Street 2",
      "PostalCode": 12345}
   ],
   "Person":{
      "FirstName": "Mike",
      "LastName":"Boe"
   }
}


{
   "Id": 2,
   "Person":{
      "FirstName": "John",
      "LastName":"Boe"
   }
   "Addresses":[
      {"Street": "Street 3",
      "PostalCode": 12345},
      {"Street": "Street 2",
      "PostalCode": 12345}
   ]
}

Posso comparar objetos aninhados um por um apontando para eles como

QueryJSON ".Person | to_entries | sort_by(.key) | from_entries"

Mas há alguma maneira de classificar propriedades também dentro desses objetos (mesmo que isso os achataria)? Obrigado.

Encontrei o seguinte nas páginas do github govc govmomi , que me permite pesquisar VMs por endereço MAC:

govc object.collect -json -type m / config.hardware.device \
  | jq -r '
      .
      | select(.ChangeSet[].Val.VirtualDevice[].MacAddress == "00:50:56:bc:5e:3c")
      | [.Obj.Type, .Obj.Value]
      | join(":")
    ' \
  | xargs govc ls -L

Em anexo, segue um trecho da saída do govc que deve ser suficiente:

{
  "Obj": {
    "Type": "VirtualMachine",
    "Value": "vm-666"
  },
  "ChangeSet": [
    {
      "Val": {
        "VirtualDevice": [
          {
          },
          {
            "MacAddress": "00:50:56:bc:5e:3c"
          }
        ]
      }
    }
  ]
}

O problema que estou enfrentando é que alguns MACs contêm letras maiúsculas, algumas minúsculas, e não sei com antecedência qual máquina usa qual esquema. Não consigo descobrir como fazer com que o ==caso não seja sensível.

Encontrei respostas aqui no stackoverflow que sugerem usar ascii_downcasecomo filtro, mas não sei como aplicar isso com o ==.

A sintaxe sugerida em https://stackoverflow.com/a/62454688 me dá uma sequência de explode input must be a stringerros (1 por linha de saída do govc).

Caso isso seja importante para este exercício: isso está acontecendo em Mac OS 15.1, jqé instalado via brew, a versão é 1.7.1.

Estou tentando gerar certificados usando a função vault pki. Como posso criar um único arquivo chamado ca.crt a partir da saída do comando wget.

$ wget --method=POST --header="X-Vault-Namespace: ns" --header="X-Vault-Token: $VAULT_TOKEN" --body-data='{"common_name": "test.example.com", "ttl": "5m"}' https://127.0.0.1:8200/v1/pki/dev/issuing_ca/issue/dev -q -O - | jq '.data.ca_chain'
Response
[
  "-----BEGIN CERTIFICATE-----\nMIIF5jCCA86W6j2PehfjWs3\nR55ogX1Z2jk/dvIIp.......Z067gh7nrDE56fzhyA=\n-----END CERTIFICATE-----",
  "-----BEGIN CERTIFICATE-----\nMIIF4DCCA8iNzdTHItwqVl1cTglr6bcry0vckey68u+.......4gR0CRtJ\nCaLcNKCBGi/jn6pekNVvgjBamsM=\n-----END CERTIFICATE-----",
  "-----BEGIN CERTIFICATE-----\nMIIFMzCCAxnNDE5MTlaFwumZ8\nHL8n10r0b35LtMT........CxSXIjAZJRE8Fh9jOIm0\n-----END CERTIFICATE-----"
]

$ cat ca.crt

-----BEGIN CERTIFICATE-----
MIIF5jCCA86W6j2PehfjWs3
.
.
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIF5jCCA86W6j2PehfjWs3
.
.
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
nMIIF4DCCA8iNzdTHItwqVl1c
.
.
-----END CERTIFICATE-----

Aqui estão os 2 itens em uma matriz:

{
  "SysID": "12345",
  "Name": "abc"
}
{
  "SysID": "12345",
  "Name": "def"
}
{
  "SysID": "23456",
  "Name": "hij"
}
{
  "SysID": "23456",
  "Name": "klm"
}
{
  "SysID": "23456",
  "Name": "nop"
}

Gostaria de transformar "SysID" em chave e "Nome" como o valor dela no array:

{
  "12345": [
    "abc",
    "def",
  ],
  "23456": [
    "hij",
    "klm",
    "nop",
  ],
}

Posso saber como fazer isso no jq?

Corresponde ao primeiro objeto que tem uma matriz que contém exatamente os mesmos valores (sempre deve ter comprimento 2)

Exemplo:

[
  { "id": 242, "size": [500, 500] },
  { "id": 234, "size": [500, 1920] },
  { "id": 168, "size": [234, 1080] },
  { "id": 315, "size": [1080, 1920] },
  { "id": 366, "size": [1920, 1080] },
  { "id": 367, "size": [1920, 1080] }
]

width=1920
height=1080

# Should match:
# { id: 366, size: [1920, 1080] }

# Then extract id (easy, got this part)

Minha melhor tentativa foi usar contains, mas parece que contains não pode receber mais de um argumento:

echo $json | jq -r ".[] | select( [ .size[] | contains($width) ] | any ) | .id"