|                  ശീർഷകം                   | വെയ്റ്റ് |
| :---------------------------------------: | :---: |
| വ്യവസ്ഥകൾക്കും ഔട്ട്പുട്ടുകൾക്കുമായുള്ള പിന്തുണച്ച ഫീൽഡുകൾ |   3   |



# ആമുഖം

ഫാൽക്കോ പിന്തുണക്കുന്ന ഫീൽഡുകൾ ഇതാ. ഈ ഫീൽഡുകൾ ഒരു ഫാൽക്കോ നിയമത്തിൻറെ `condition` കീയിലും `output` കീയിലും ഉപയോഗിക്കാൻ കഴിയും.   [`json_output`](../../alerts#json-output) എന്നത് `true` ആയി സെറ്റ് ചെയ്യുമ്പോൾ, നിയമത്തിൻറെ `output` കീയിൽ ഉൾപ്പെട്ട ഏത് ഫീൽഡുകളും അലേർട്ടിൻറെ `output_fields` ഓബ്ജക്റ്റിലും ഉൾപ്പെടുന്നു. 

നിങ്ങൾക്ക് ഈ ഫീൽഡുകളുടെ സെറ്റ്, `falco --list=<source>` എന്നത് വഴി `<source>` എന്നത് താഴെയുള്ള ഉറവിടങ്ങളിലൊന്നായിട്ടും കാണാവുന്നതാണ്.

# സിസ്റ്റം കോളുകൾ (ഉറവിട

#  `syscall`)

`syscall` ഇവൻറ് ഉറവിടഫീൽഡുകൾ  [kernel module](/docs/event-sources/drivers/) ആണ് ലഭ്യമാക്കുന്നത്. ഈ ഫീൽഡുകൾ സിസ്ഡിഗ് കാപ്ച്ചറുകൾ ഫിൽട്ടർ ചെയ്യാൻ ഉപയോഗിക്കാവുന്ന [Sysdig filter fields](https://github.com/draios/sysdig/wiki/Sysdig-User-Guide#all-supported-filters) എന്നതിന് സമാനമാണ്.

```
# System Kernel Fields
$ falco --list=syscall
```

## `fd` ഫീൽഡ് ക്ലാസ്സ്

ഫയൽ ഡിസ്ക്രിപ്റ്റേഴ്സിനായുള്ള ഫീൽഡ്. ഫയൽ/ഡയറക്റ്ററി ഫീൽഡുകളും നെറ്റ്വർക്കിങ്ങും ഉൾപ്പെടുന്നു.

```
fd.num          ഫയൽ ഡിസ്ക്രിപ്റ്ററിനെ തിരിച്ചറിയുന്ന അദ്വിതീയമായ സംഖ്യ.
fd.type         ഒരു തരം FD. 'file', 'directory', 'ipv4', 'ipv6', 'unix',
                'pipe', 'event', 'signalfd', 'eventpoll', 'inotify','signal
                അല്ലെങ്കിൽ 'signal fd' എന്നിവയാകാം .
fd.typechar     ഒരൊറ്റ പ്രതീകമായുള്ള ഒരു FD തരം.ഫയലിന് 'f',IP v4 socket ന് 4, IPv6                   socket ന് 6,unix socket ന് 'u' ,pipe ന് p ,
                eventfd ക്ക് 'e' , signalfd ക്ക് 's',eventpoll ന് 'l', i notify എന്നതിന്                   'i', unknown ന് 'o' എന്നിങ്ങനെയാകാം.
fd.name         FD മുഴുവൻ പേര്.fd ഒരു ഫയലാണെങ്കിൽ, ഈ ഫീൽഡ് മുഴുവൻ പാതയും                   ഉൾക്കൊള്ളുന്നു. FD ഒരു സോക്കറ്റാണെങ്കിൽ,ഈ ഫീൽഡ് കണക്ഷൻ ട്യൂപ്പിൾ                 ഉൾക്കൊള്ളുന്നു.
fd.directory    fd ഒരു ഫയലാണെങ്കിൽ, അത് ഉൾക്കൊള്ളുന്ന ഡയറക്റ്ററി.
fd.filename     fd ഒരു ഫയലാണെങ്കിൽ, മാർഗ്ഗം ഉൾക്കൊള്ളാത്ത ഫയൽനാമം.
fd.ip           (ഫിൽട്ടർ മാത്രം) fd യുടെ  ip അഡ്രസ്സുമായി (ക്ലൈൻറ് അല്ലെങ്കിൽ സർവർ)                 പൊരുത്തപ്പെടുന്നു.
fd.cip          ക്ലൈൻറ് IP അഡ്രസ്സ്.
fd.sip          സർവർ IP അഡ്രസ്സ്.
fd.lip          പ്രാദേശിക IP അഡ്രസ്സ്.
fd.rip          വിദൂര IP അഡ്രസ്സ്.
fd.port         (ഫിൽട്ടർ മാത്രം) fd യുടെ പോർട്ടുമായി (ഒന്നുകിൽ ക്ലൈൻറ് അല്ലെങ്കിൽ                     സർവർ) പൊരുത്തപ്പെടുന്നു.
fd.cport        TCP/UDP FDകൾക്കായി, ക്ലൈൻറ് പോർട്ട്.
fd.sport        TCP/UDP FDകൾക്കായി, സർവർ പോർട്ട്.
fd.lport        TCP/UDP FDകൾക്കായി, പ്രാദേശിക പോർട്ട്.
fd.rport        TCP/UDP FDകൾക്കായി, വിദൂര പോർട്ട്.
fd.l4proto      ഒരു സോക്കറ്റിൻറെ IP പ്രോട്ടോക്കോൾ.'tcp', 'udp', 'icmp' അല്ലെങ്കിൽ                     'raw' എന്നിവയാകാം.
fd.sockfamily   സോക്കറ്റ് ഇവൻറുകൾക്കായുള്ള സോക്കറ്റ് കൂടുംബം. 'ip' അല്ലെങ്കിൽ 'unix'                 ആകാം.
fd.is_server    ഈ FDയുടെ ഉടമസ്ഥതയുള്ള പ്രക്രിയയാണ് കണക്ഷനിൽ സർവർ എൻഡ്                     പോയിൻറ് എങ്കിൽ 'true'.
fd.uid          FD സംഖ്യ, ത്രെഡ് ID എന്നിവ ചെയിൻ ചെയ്യുന്നതിലൂടെ നിർമ്മിച്ച                           FDക്കായുള്ള ഒരു അദ്വിതീയമായ ഐഡൻറിഫയർ.
fd.containername
                കണ്ടെയ്നർ ID,FD നാമം എന്നിവയുടെ ചെയ്നിങ്.ഒരു FD ഏത് കണ്ടെയ്നറിലാണ്                   ഉൾപ്പെടുന്നെന്ന് തിരിച്ചറിയാൻ ശ്രമിക്കുമ്പോൾ ഉപകാരപ്രദം.
fd.containerdirectory
                കണ്ടെയ്നർ ID,ഡയറക്റ്ററി നാമം എന്നിവയുടെ ചെയ്നിങ്. ഒരു ഡയറക്റ്ററി ഏത്                 കണ്ടെയ്നറിലാണ് ഉൾപ്പെടുന്നെന്ന് തിരിച്ചറിയാൻ ശ്രമിക്കുമ്പോൾ ഉപകാരപ്രദം.
fd.proto        (ഫിൽട്ടർ മാത്രം) fdയുടെ പ്രോട്ടോക്കോളുമായി (ഒന്നുകിൽ ക്ലൈൻറ്                         അല്ലെങ്കിൽ സർവർ) പൊരുത്തപ്പെടുന്നു.
fd.cproto       TCP/UDP FDകൾക്കായി, ക്ലൈൻറ് പ്രോട്ടോക്കോൾ.
fd.sproto       TCP/UDP FDകൾക്കായി, സർവർ പ്രോട്ടോക്കോൾ.
fd.lproto       TCP/UDP FDകൾക്കായി, പ്രാദേശിക പ്രോട്ടോക്കോൾ.
fd.rproto       TCP/UDP FDകൾക്കായി, വിദൂര പ്രോട്ടോക്കോൾ.
fd.net          (ഫിൽട്ടർ മാത്രം) fdയുടെ IP നെറ്റ്വർക്കുമായി(ക്ലൈൻറ് അല്ലെങ്കിൽ സർവർ)                 പൊരുത്തപ്പെടുന്നു.
fd.cnet         (ഫിൽട്ടർ മാത്രം) fdയുടെ ക്ലൈൻറ് IP നെറ്റ്വർക്കുമായി           
                പൊരുത്തപ്പെടുന്നു.
fd.snet         (ഫിൽട്ടർ മാത്രം) fdയുടെ സർവർ IP നെറ്റ്വർക്കുമായി
                പൊരുത്തപ്പെടുന്നു.
fd.lnet         (ഫിൽട്ടർ മാത്രം) fdയുടെ പ്രാദേശിക IP നെറ്റ്വർക്കുമായി
                പൊരുത്തപ്പെടുന്നു.
fd.rnet         (ഫിൽട്ടർ മാത്രം) fdയുടെ വിദൂര IP നെറ്റ്വർക്കുമായി
                പൊരുത്തപ്പെടുന്നു.
fd.connected    TCP/UDP FDകൾക്കായി,സോക്കറ്റ് കണക്റ്റഡാണെങ്കിൽ 'true'.
fd.name_changed ഈ ഇവൻറ് ഉപയോഗിക്കുന്ന ഒരു fdയുടെ പേര് ഒരു ഇവൻറ്                                 മാറ്റുകയാണെങ്കിൽ സത്യം.കണക്ഷൻ ട്യൂപ്പിൾ മാറുന്ന കണക്ഷനുകൾ                         പോലുള്ള ചില സാഹചര്യങ്ങളിൽ ഇത് സംഭവിക്കാം.
fd.cip.name     ക്ലൈൻറ് IP അഡ്രസ്സുമായി ബന്ധപ്പെട്ട ഡൊമെയ്ൻ നാമം.
fd.sip.name     സർവർ IP അഡ്രസ്സുമായി ബന്ധപ്പെട്ട ഡൊമെയ്ൻ നാമം.
fd.lip.name     പ്രാദേശിക IP അഡ്രസ്സുമായി ബന്ധപ്പെട്ട ഡൊമെയ്ൻ നാമം.
fd.rip.name     വിദൂര IP അഡ്രസ്സുമായി ബന്ധപ്പെട്ട ഡൊമെയ്ൻ നാമം.
fd.dev          റഫറൻസ്ഡ് ഫയൽ ഉൾക്കൊള്ളുന്ന ഡിവൈസ് നമ്പർ (മേജർ/മൈനർ).
fd.dev.major    റഫറൻസ്ഡ് ഫയൽ ഉൾക്കൊള്ളുന്ന മേജർ ഡിവൈസ് നമ്പർ.
fd.dev.minor    റഫറൻസ്ഡ് ഫയൽ ഉൾക്കൊള്ളുന്ന മൈനർ ഡിവൈസ് നമ്പർ.
```

## `proc` & `thread` ഫീൽഡ് ക്ലാസ്സ്

സ്പോൺ ചെയ്ത പ്രക്രിയയോ ത്രെഡുകളോ റൺ ചെയ്യുന്നതിനുള്ള ഫീൽഡുകൾ.

```
Field Class: പ്രക്രിയ

proc.pid        ഇവൻറ് ജനറേറ്റ് ചെയ്യുന്ന പ്രക്രിയയുടെ ഐഡി.
proc.exe        ആദ്യത്തെ കമാൻഡ് ലൈൻ ആർഗ്യുമെൻറ് (സാധാരണയായി ഒരു                           എക്സിക്ക്യൂട്ടബിൾ പേര് അല്ലെങ്കിൽ ഒരു കസ്റ്റം ആയ ഒന്ന്).
proc.name       ഇവൻറ് ജനറേറ്റ് ചെയ്യുന്ന എക്സിക്ക്യൂട്ടബിളിൻറെ പേര്(മാർഗ്ഗം                                 ഒഴിവാക്കിക്കൊണ്ടുള്ളത്).
proc.args       ഇവൻറ് ജനറേറ്റ് ചെയ്യുന്ന പ്രക്രിയ തുടങ്ങുമ്പോൾ കമാൻഡ്                                   ലൈനിലൂടെ കടന്നുപോകുന്ന ആർഗ്യുമെൻറുകൾ. 
proc.env        ഇവൻറ് ജനറേറ്റ് ചെയ്യുന്ന പ്രക്രിയയുടെ പരിതസ്ഥിതി                                       വാരിയബിളുകൾ.
proc.cmdline    മുഴുവൻ പ്രക്രിയ കമാൻഡ് ലൈൻ, അതായത് proc.name +proc.args.
proc.exeline    exe എന്നത് ആദ്യത്തെ ആർഗ്യുമെൻറായുള്ള,മുഴുവൻ പ്രക്രിയ                               കമാൻഡ് ലൈൻ. അതായത് proc.exe + proc.args.
proc.cwd        ഇവൻറിൻറെ നിലവിലെ പ്രവർത്തിക്കുന്ന ഡയറക്റ്ററി.
proc.nthreads   പ്രധാന പ്രക്രിയാ ത്രെഡ് ഉൾപ്പെടെ, ഇവൻറ് ജനറേറ്റ് ചെയ്യുന്ന                                 പ്രക്രിയക്ക് നിലവിലുള്ള ത്രെഡ്ഡുകളുടെ എണ്ണം.
proc.nchilds    ഇവൻറ് ജനറേറ്റ് ചെയ്യുന്ന പ്രക്രിയക്ക് നിലവിലുള്ള കുഞ്ഞുത്രെഡ്ഡുകളുടെ                     എണ്ണം. ഇതിൽ പ്രധാന പ്രക്രിയാ ത്രെഡ് ഉൾപ്പെടുന്നില്ല.
proc.ppid       ഇവൻറ് ജനറേറ്റ് ചെയ്യുന്ന പ്രക്രിയയുടെ പാരെൻറിൻറെ പിഡ്.
proc.pname      ഇവൻറ് ജനറേറ്റ് ചെയ്യുന്ന പ്രക്രിയയുടെ പാരെൻറിൻറെ പേര്(മാർഗ്ഗം                           ഒഴിവാക്കിക്കൊണ്ടുള്ളത്).
proc.pcmdline   ഇവൻറ് ജനറേറ്റ് ചെയ്യുന്ന പ്രക്രിയയുടെ പാരെൻറിൻറെ മുഴുവൻ                               കമാൻഡ് ലൈൻ(proc.name + proc.args) 
proc.apid       പ്രക്രിയാമുൻഗാമികളിലൊന്നിൻറെ പിഡ്. ഉദാ: proc.apid[1]  പാരെൻറ് പിഡ്                 തിരികെ തരുന്നു, proc.apid[2] ഗ്രാൻറ്പാരെൻറ് പിഡ് തിരികെ തരുന്നു,                     അങ്ങനെയങ്ങനെ. proc.apid[0] നിലവിലെ പ്രക്രിയയുടെ പിഡ് ആണ്.                       ആർഗ്യുമെൻറുകളില്ലാത്ത proc.apid ഫിൽട്ടറുകളിൽ മാത്രമേ                                 ഉപയോഗിക്കാനാവൂ, കൂടാതെ ഏതൊരു പ്രക്രിയാമുൻഗാമികളുമായും അത്                   പൊരുത്തപ്പെടുന്നു, ഉദാ: proc.apid=1234.
proc.aname      പ്രക്രിയാമുൻഗാമികളിലൊന്നിൻറെ പേര് (മാർഗ്ഗം ഉൾപ്പെടാത്തത്) 
                ഉദാ: proc.aname[1] പാരെൻറ് നാമം തിരികെ തരുന്നു, proc.aname[2] ഗ്രാൻറ്                 പാരെൻറ് നാമം തിരികെ തരുന്നു, അങ്ങനെയങ്ങനെ. proc.aname[0]                         നിലവിലെ പ്രക്രിയയുടെ പേര് ആണ്. ആർഗ്യുമെൻറുകളില്ലാത്ത proc.aname                   ഫിൽട്ടറുകളിൽ മാത്രമേ ഉപയോഗിക്കാനാവൂ, കൂടാതെ ഏതൊരു                             പ്രക്രിയാമുൻഗാമികളുമായും അത് പൊരുത്തപ്പെടുന്നു,ഉദാ: proc.aname=bash.
proc.loginshellid
                നിലവിലെ പ്രക്രിയയുടെ മുൻഗാമികളിലെ ഏറ്റവും പഴയ ഷെല്ലിൻറെ പിഡ്,                   അങ്ങനെയൊന്നുണ്ടെങ്കിൽ. ഈ ഫീൽഡ് വ്യത്യസ്ത ഉപയോക്തൃ സെഷനുകളെ                 വേർതിരിക്കാൻ ഉപയോഗിക്കാവുന്നതാണ്, കൂടാതെ spy_user പോലുള്ള                       ചിസെലുകളുപയോഗിച്ചുള്ള സംയോജനത്തിൽ ഇത് ഉപകാരപ്രദമാണ്.
proc.duration   പ്രക്രിയ ആരംഭിച്ചതുമുതൽക്കുള്ള നാനോസെക്കൻറുകളുടെ എണ്ണം.
proc.fdopencount
                പ്രക്രിയക്കായുള്ള ഓപ്പൺ FDകളുടെ എണ്ണം
proc.fdlimit    പ്രക്രിയക്ക് ഓപ്പൺ ചെയ്യാൻ കഴിയുന്ന പരമാവധി FDകളുടെ എണ്ണം.
proc.fdusage    പ്രക്രിയക്കായുള്ള ഓപ്പൺ FDകളും ലഭ്യമായ പരമാവധി FDകളും തമ്മിലുള്ള                   അനുപാതം.
proc.vmsize     പ്രക്രിയക്കായുള്ള മൊത്തം വേർച്വൽ മെമ്മറി (kb രൂപത്തിൽ).
proc.vmrss      പ്രക്രിയക്കായുള്ള റെസിഡെൻറ് നോൺ-സ്വാപ്പ്ഡ് മെമ്മറി (kb രൂപത്തിൽ).
proc.vmswap     പ്രക്രിയക്കായുള്ള സ്വാപ്പ്ഡ് മെമ്മറി (kb രൂപത്തിൽ).
thread.pfmajor  ത്രെഡ് ആരംഭം മുതലുള്ള മേജർ പേജ് പിശകുകളുടെ എണ്ണം.
thread.pfminor  ത്രെഡ് ആരംഭം മുതലുള്ള മൈനർ പേജ് പിശകുകളുടെ എണ്ണം.
thread.tid      ഇവൻറ് ജനറേറ്റ് ചെയ്യുന്ന ത്രെഡ്ഡിൻറെ ഐഡി.
thread.ismain   പ്രക്രിയയിലെ പ്രധാനപ്പെട്ടത് ഇവൻറ് ജനറേറ്റ് ചെയ്യുന്ന ത്രെഡ്ഡാണെങ്കിൽ                       'true'.
thread.exectime അവസാനം ഷെഡ്യൂൾ ചെയ് ത്രെഡ് ചിലവഴിച്ച CPU സമയം,                                 നാനോസെക്കൻറിൽ. സ്വിച്ച് ഇവൻറുകളാൽ മാത്രം എക്സ്പോർട്ട് ചെയ്തത്.
thread.totexectime
                നിലവിലെ ത്രെഡ്ഡിനായുള്ള കാപ്ചറിൻറെ തുടക്കം മുതൽക്കുള്ള മൊത്തം                       CPU സമയം, നാനോസെക്കൻറിൽ. സ്വിച്ച് ഇവൻറുകളാൽ മാത്രം                             എക്സ്പോർട്ട് ചെയ്തത്.
thread.cgroups  ത്രെഡ്ഡ് ഉൾപ്പെടുന്ന cgroups എല്ലാം, ഒരൊറ്റ സ്ട്രിങ്ങിലേക്ക് ചേർത്തത്.
thread.cgroup   ഒരു പ്രത്യേക സബ്സിസ്റ്റത്തിനായുള്ള, ത്രെഡ്ഡ് ഉൾപ്പെടുന്ന cgroup.ഉദാ:                         thread.cgroup.cpuacct.
thread.vtid     അതിൻറെ നിലവിലെ PID നെയിംസ്പേസിലേതുപോലെ, ഇവൻറ് ജനറേറ്റ്                     ചെയ്യുന്ന ത്രെഡ്ഡിൻറെ ഐഡി. 
proc.vpid       അതിൻറെ നിലവിലെ PID നെയിംസ്പേസിലേതുപോലെ, ഇവൻറ് ജനറേറ്റ്                     ചെയ്യുന്ന പ്രക്രിയയുടെ ഐഡി.
thread.cpu      അവസാന സെക്കൻറിൽ ത്രെഡ്ഡ് ഉപയോഗിക്കുന്ന CPU.
thread.cpu.user അവസാന സെക്കൻറിൽ ത്രെഡ്ഡ് ഉപയോഗിക്കുന്ന ഉപയോക്തൃ CPU.
thread.cpu.system
                അവസാന സെക്കൻറിൽ ത്രെഡ്ഡ് ഉപയോഗിക്കുന്ന സിസ്റ്റം CPU.
thread.vmsize   പ്രക്രിയാപ്രധാന ത്രെഡ്ഡിനായി, ഇതാണ് പ്രക്രിയക്കായുള്ള വേർച്വൽ മെമ്മറി                   (kb രൂപത്തിൽ). മറ്റ് ത്രെഡ്ഡുകൾക്ക്, ഈ ഫീൽഡ് പൂജ്യമാണ്.
thread.vmrss    പ്രക്രിയാപ്രധാന ത്രെഡ്ഡിനായി, ഇതാണ് പ്രക്രിയക്കായുള്ള റെസിഡെൻറ്                       നോൺ-സ്വാപ്പ്ഡ് മെമ്മറി (kb രൂപത്തിൽ). മറ്റ് ത്രെഡ്ഡുകൾക്ക്, ഈ ഫീൽഡ്                   പൂജ്യമാണ്.
proc.sid        ഇവൻറ് ജനറേറ്റ് ചെയ്യുന്ന പ്രക്രിയയുടെ സെഷൻ ഐഡി..
proc.sname      നിലവിലെ പ്രക്രിയയുടെ സെഷൻ ലീഡറിൻറെ ഐഡി. ഇത് ഒന്നുകിൽ  pid=proc.sid    എന്നതിനൊപ്പമുള്ള പ്രക്രിയയോ അല്ലെങ്കിൽ നിലവിലെ പ്രക്രിയക്ക്                           സമാനമായ സിഡ് ഉള്ള ഏറ്റവും പ്രായമേറിയ മുൻഗാമി.
proc.tty        പ്രക്രിയയുടെ നിയന്ത്രണ ടെർമിനൽ. ടെർമിനൽ ഇല്ലാത്ത പ്രക്രിയകൾക്ക് 0.
proc.exepath    പ്രക്രിയയുടെ പൂർണ്ണമായി എക്സിക്ക്യൂട്ട് ചെയ്യാവുന്ന മാർഗ്ഗം .
proc.vpgid      ഇവൻറ് ജനറേറ്റ് ചെയ്യുന്ന പ്രക്രിയയുടെ പ്രക്രിയാസംഘ ഐഡി, അതിൻറെ                   നിലവിലെ PID നെയിംസ്പേസിൽ നിന്നും കണ്ടതനുസരിച്ചുള്ളത്.
proc.is_container_healthcheck
                കണ്ടെയ്നറിൻറെ ആരോഗ്യപരിശോധനയുടെ ഭാഗമായാണ് ഈ പ്രക്രിയ റൺ                     ചെയ്യുന്നതെങ്കിൽ, ട്രൂ.
```

## `evt` ഫീൽഡ് ക്ലാസ്സ്

സിസ്റ്റം കോൾ ഇവൻറുകൾക്കായുള്ള ഫീൽഡുകൾ. സിസ്റ്റം കോളിൻറെ പേര് വ്യക്തമാക്കുന്നതിന് `evt.type` ഉപയോഗിക്കുക. ഓരോ ഫാൽക്കോ `syscall` നിയമത്തിനും കുറഞ്ഞത് ഒരു `evt` ഫീൽഡെങ്കിലും ആവശ്യമാണ്.

```
evt.num         ഇവൻറ് നമ്പർ.
evt.time        നാനോസെക്കൻറ് ഭാഗം ഉൾക്കൊള്ളുന്ന ടൈംസ്ട്രിങ്ങായ ഇവൻറ്                             ടൈംസ്റ്റാമ്പ്.
evt.time.s      നാനോസെക്കൻറ് ഭാഗം ഉൾക്കൊള്ളാത്ത ടൈംസ്ട്രിങ്ങായ ഇവൻറ്                             ടൈംസ്റ്റാമ്പ്.
evt.time.iso8601
                നാനോസെക്കൻറുകളും ടൈംസോൺ ഓഫ്സെറ്റും ഉൾക്കൊള്ളുന്ന ISO 8601                   ഫോർമാറ്റിലുള്ള ഇവൻറ് ടൈംസ്റ്റാമ്പ്(UTCയിൽ).
evt.datetime    തീയ്യതി ഉൾക്കൊള്ളുന്ന ടൈംസ്ട്രിങ്ങായ ഇവൻറ് ടൈംസ്റ്റാമ്പ്.
evt.rawtime     കേവല ഇവൻറ് ടൈംസ്റ്റാമ്പ്, അതായത്, എപക് മുതലുള്ള                                   നാനോസെക്കൻറുകൾ.
evt.rawtime.s   ഇവൻറ് ടൈംസ്റ്റാമ്പിൻറെ പൂർണ്ണസംഖ്യാഭാഗം (ഉദാ: എപക് മുതലുള്ള                         സെക്കൻറുകൾ).
evt.rawtime.ns  കേവല ഇവൻറ് ടൈംസ്റ്റാമ്പിൻറെ ഭിന്നസംഖ്യാഭാഗം.
evt.reltime     കാപ്ചറിൻറെ തുടക്കം മുതലുള്ള നാനോസെക്കൻറുകളുടെ എണ്ണം.
evt.reltime.s   കാപ്ചറിൻറെ തുടക്കം മുതലുള്ള സെക്കൻറുകളുടെ എണ്ണം.
evt.reltime.ns  കാപ്ചറിൻറെ തുടക്കം മുതലുള്ള സമയത്തിൻറെ ടൈംസ്റ്റാമ്പിൻറെ                             ഭിന്നസംഖ്യാഭാഗം(ns ൽ)
evt.latency     ഒരു എക്സിറ്റ് ഇവൻ്റിനും കറസ്പോണ്ടൻറ് എൻറർ ഇവൻറിനും ഇടയിലുള്ള                     ഡെൽറ്റ,നാനോസെക്കൻറിൽ.
evt.latency.s   ഇവൻറ് ലേറ്റൻസി ഡെൽറ്റയുടെ പൂർണ്ണസംഖ്യാഭാഗം.
evt.latency.ns  ഇവൻറ് ലേറ്റൻസി ഡെൽറ്റയുടെ ഭിന്നസംഖ്യാഭാഗം.
evt.latency.human
                ഒരു എക്സിറ്റ് ഇവൻ്റിനും കറസ്പോണ്ടൻറ് എൻറർ ഇവൻറിനും ഇടയിലുള്ള                     ഡെൽറ്റ,മനുഷ്യന് വായിക്കാൻ കഴിയുന്ന സ്ട്രിങ്ങിൻറെ രൂപത്തിൽ (ഉദാ:                     10.3ms).
evt.deltatime   ഈ ഇവൻറിനും ഇതിന് മുൻപുള്ള ഇവൻറിനും ഇടയിലുള്ള ഡെൽറ്റ,                         നാനോസെക്കൻറിൽ.
evt.deltatime.s ഈ ഇവൻറിനും ഇതിന് മുൻപുള്ള ഇവൻറിനും ഇടയിലുള്ള ഡെൽറ്റയുടെ                     പൂർണ്ണസംഖ്യാഭാഗം.
evt.deltatime.ns
                ഈ ഇവൻറിനും ഇതിന് മുൻപുള്ള ഇവൻറിനും ഇടയിലുള്ള ഡെൽറ്റയുടെ                     ഭിന്നസംഖ്യാഭാഗം.
evt.outputtime  ഇത് -t param എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു, ഡീഫോൾട്ട് %evt.time ('h')                 എന്നതാണ്.
evt.dir         ഇവൻറ് ദിശ ഒന്നുകിൽ എൻറർ ഇവൻറുകൾക്കുള്ള '>' എന്നതോ അല്ലെങ്കിൽ                 എക്സിറ്റ് ഇവൻറുകൾക്കുള്ള '<' എന്നതോ ആകാം.
evt.type        ഇവൻറിൻറെ പേര് (ഉദാ: 'open').
evt.type.is     ഒരു ഇവൻറ് തരത്തിനെ വ്യക്തമാക്കാൻ ഒന്നിനെ അനുവദിക്കുകയും, ആ                     തരത്തിലുള്ള ഇവൻറുകൾക്കായി 1 തിരികെത്തരുന്നു.ഉദാഹരണത്തിന്,                       ഓപ്പൺ ഇവൻറുകൾക്കായി 1 തിരികെത്തരുന്നു,മറ്റേത ഇവൻറിനായും 0.
syscall.type    സിസ്റ്റം കോൾ ഇവൻറുക്കുള്ള, സിസ്റ്റം കോൾ ഇവൻറ് (ഉദാ:'open'). മറ്റ്                     ഇവൻറുകൾക്ക് സജ്ജമാക്കിയിട്ടില്ല (ഉദാ: സ്വിച്ച് അല്ലെങ്കിൽ സിസ്ഡിഗ്                         ഇൻറേണൽ ഇവൻറുകൾ).ഫിൽട്ടർ ചെയ്ത/പ്രിൻറ് ചെയ്ത മൂല്യം യഥാർത്ഥത്തിൽ                 ഒരു സിസ്റ്റം കോളാണ് എന്ന് നിങ്ങൾക്ക് ഉറപ്പുവരുത്തണമെന്നുണ്ടെങ്കിൽ                       evt.type എന്നതിന് പകരം ഈ ഫീൽഡ് ഉപയോഗിക്കുക.
evt.category    ഇവൻറ് വിഭാഗം. ഉദാഹരണമൂല്യങ്ങൾ 'file' (ഓപ്പൺ, ക്ലോസ് എന്നിവ                     പോലുള്ള ഫയൽ ഓപ്പറേഷനുകൾക്കായി), 'net' (സോക്കറ്റ്, ബൈൻഡ്                       എന്നിവപോലുള്ള നെറ്റ്വർക്ക് ഓപ്പറേഷനുകൾക്കായി), മെമ്മറി ( brk                       അല്ലെങ്കിൽ mmap എന്നിവപോലുള്ള കാര്യങ്ങൾക്കായി) തുടങ്ങിയവയാണ്.
evt.cpu         ഈ ഇവൻറ് സംഭവിച്ച CPUവിൻറെ നമ്പർ.
evt.args        ഒരൊറ്റ സ്ട്രിങ്ങിലേക്ക് ചേർത്ത എല്ലാ ഇവൻറ് ആർഗ്യുമെൻറുകളും.
evt.arg         പേര് അല്ലെങ്കിൽ നമ്പർ വ്യക്തമാക്കിയിട്ടുള്ള ഇവൻറ്                                         ആർഗ്യുമെൻറുകളിലൊന്ന്. ചില ഇവൻറുകൾ(ഉദാ: കോഡുകൾ അല്ലെങ്കിൽ                   FDകൾ തിരികെത്തരുക) സാധ്യമാകുമ്പോൾ ഒരു ടെക്സ്റ്റ്                                     റെപ്രസെൻറേഷനിലേക്ക് മാറ്റപ്പെടും. ഉദാ: 'evt.arg.fd' അല്ലെങ്കിൽ 'evt.arg                 [0]'.
evt.rawarg      പേര് വ്യക്തമാക്കിയിട്ടുള്ള ഇവൻറ് ആർഗ്യുമെൻറുകളിലൊന്ന്. ഉദാ:                           'evt.rawarg.fd'.
evt.info        മിക്ക ഇവൻറുകൾക്കും, ഈ ഫീൽഡ് evt.args എന്നതിൻറെ അതേ മൂല്യമാണ്                 തിരിച്ചുതരുന്നത്.
                ഏതായാലും, ചില ഇവൻറുകൾക്ക് (/dev/log എന്നതിലേക്കുള്ള എഴുതൽ                     പോലെയുള്ള), ആർഗ്യുമെൻറുകൾ ഡീകോഡ് ചെയ്യുന്നതിൽ നിന്നും വരുന്ന                   കൂടുതൽ ഉയർന്ന നിലവാരത്തിലുള്ള വിവരങ്ങൾ ലഭ്യമാക്കുന്നു.
evt.buffer      read(), recvfrom(), മുതലായവ പോലെ ഒന്നുള്ള ഇവൻറുകൾക്ക് ബൈനറി                   ഡാറ്റ ബഫർ ചെയ്യുന്നു. I/O ഡാറ്റ ബഫറുകളിലേക്ക് സർച്ച് ചെയ്യാൻ                           'contains' എന്നതുള്ള ഫിൽട്ടറുകളിൽ ഈ ഫീൽഡ് ഉപയോഗിക്കുക.
evt.buflen      ബൈനറി ഡാറ്റയുടെ ദൈർഘ്യം read(), recvfrom(), മുതലായവ പോലെ                     ഒന്നുള്ള ഇവൻറുകൾക്ക് ബഫർ ചെയ്യുന്നു.
evt.res         ഇവൻറ് തിരിച്ചുനൽകൽ മൂല്യം, ഒരു സ്ട്രിങ്ങായിട്ട്. ഇവൻറ്                                 പരാജയപ്പെട്ടിട്ടുണ്ടെങ്കിൽ, ഫലം ഒരു പിശകുള്ള കോഡ് സ്ട്രിങ്ങാണ്(ഉദാ:                     'ENOENT'), അതല്ലെങ്കിൽ, ഫലം 'SUCCESS' എന്ന സ്ട്രിങ്ങായിരിക്കും.
evt.rawres      ഇവൻറ് തിരിച്ചുനൽകൽ മൂല്യം, ഒരു നമ്പറായിട്ട് (ഉദാ: -2). റേഞ്ച്                           താരതമ്യങ്ങൾക്ക് ഉപകാരപ്രദം.
evt.failed      ഒരു പിശക് സ്റ്റാറ്റസ് തിരിച്ചുതന്ന ഇവൻറുകൾക്ക് 'true'.
evt.is_io       read(), send, recvfrom(),മുതലായവ പോലുള്ള FDകൾ വായിക്കുകയോ                       അതിലേക്ക് എഴുതുകയോ ചെയ്യുന്ന ഇവൻറുകൾക്ക് 'true'.
evt.is_io_read  read(), recv(), recvfrom() മുതലായവ പോലുള്ള FDകളിൽ നിന്നും                           വായിക്കുന്ന ഇവൻറുകൾക്ക് 'true'.
evt.is_io_write write(), send(), മുതലായവ പോലുള്ള FDകളിലേക്ക് എഴുതുന്ന                               ഇവൻറുകൾക്ക് 'true'.
evt.io_dir      read() പോലുള്ള FDകളിൽ നിന്നും വായിക്കുന്ന ഇവൻറുകൾക്ക് 'r' ; write()                 പോലുള്ള FDകളിലേക്ക് എഴുതുന്ന ഇവൻറുകൾക്ക് 'w' .
evt.is_wait     ത്രെഡ്ഡിനെ വെയ്റ്റ് ചെയ്യിപ്പിക്കുന്ന ഇവൻറുകൾക്ക്,'true'. ഉദാ: sleep(), sele
                ct(), poll().
evt.wait_latency
                ത്രെഡ്ഡിനെ വെയ്റ്റ് ചെയ്യിപ്പിക്കുന്ന ഇവൻറുകൾക്ക് (ഉദാ: sleep(), select(), p
                oll()), ഇതാണ് ഇവൻറ് തിരിച്ചുവരുന്നതിനായി വെയ്റ്റ് ചെയ്യുന്ന                             നാനോസെക്കൻറിലുള്ള സമയം.
evt.is_syslog   /dev/log എന്നതിലേക്കുള്ള എഴുത്തുകളായ ഇവൻറുകൾക്ക് 'true'.
evt.count       ഈ ഫിൽട്ടർ ഫീൽഡ് എല്ലായ്പ്പോഴും 1 തിരികെത്തരുകയും                                 ചിസെലുകൾക്കുള്ളിൽ ഇവൻറുകൾ എണ്ണുന്നതിന് ഉപയോഗിക്കാൻ                             കഴിയുകയും ചെയ്യും.
evt.count.error ഈ ഫീൽട്ടർ ഫീൽഡ് ഒരു പിശകോടെ തിരികെവരുന്ന ഇവൻറുകൾക്കായി 1                 തിരികെത്തരുന്നു, കൂടാതെ ചിസെലുകൾക്കുള്ളിൽ ഇവൻറ് പരാജയങ്ങൾ                     എണ്ണുന്നതിന് ഉപയോഗിക്കാൻ കഴിയുകയും ചെയ്യും.
evt.count.error.file
                ഈ ഫീൽട്ടർ ഫീൽഡ് ഒരു പിശകോടെ തിരികെവരുന്ന ഇവൻറുകൾക്കായി 1                 തിരികെത്തരുന്നതും, ഫയൽ I/O എന്നതുമായി ബന്ധപ്പെട്ടതുമാണ്, കൂടാതെ                 ചിസെലുകൾക്കുള്ളിൽ ഇവൻറ് പരാജയങ്ങൾ എണ്ണുന്നതിന് ഉപയോഗിക്കാൻ                   കഴിയുകയും ചെയ്യും.
evt.count.error.net
                ഈ ഫീൽട്ടർ ഫീൽഡ് ഒരു പിശകോടെ തിരികെവരുന്ന ഇവൻറുകൾക്കായി 1                 തിരികെത്തരുന്നതും, നെറ്റ്വർക്ക് I/O എന്നതുമായി ബന്ധപ്പെട്ടതുമാണ്,                       കൂടാതെ ചിസെലുകൾക്കുള്ളിൽ ഇവൻറ് പരാജയങ്ങൾ എണ്ണുന്നതിന്                           ഉപയോഗിക്കാൻ കഴിയുകയും ചെയ്യും.
evt.count.error.memory
                ഈ ഫീൽട്ടർ ഫീൽഡ് ഒരു പിശകോടെ തിരികെവരുന്ന ഇവൻറുകൾക്കായി 1                 തിരികെത്തരുന്നതും,  മെമ്മറി അലോക്കേഷനുമായി ബന്ധപ്പെട്ടതുമാണ്,                     കൂടാതെ ചിസെലുകൾക്കുള്ളിൽ ഇവൻറ് പരാജയങ്ങൾ എണ്ണുന്നതിന്                           ഉപയോഗിക്കാൻ കഴിയുകയും ചെയ്യും.
evt.count.error.other
                ഈ ഫീൽട്ടർ ഫീൽഡ് ഒരു പിശകോടെ തിരികെവരുന്ന ഇവൻറുകൾക്കായി 1                 തിരികെത്തരുന്നു, അത് മുൻപുള്ള വിഭാഗങ്ങളൊന്നുമായും                                   ബന്ധപ്പെട്ടതല്ല, കൂടാതെ ചിസെലുകൾക്കുള്ളിൽ ഇവൻറ് പരാജയങ്ങൾ                         എണ്ണുന്നതിന് ഉപയോഗിക്കാൻ കഴിയുകയും ചെയ്യും.
evt.count.exit  ഈ ഫീൽട്ടർ ഫീൽഡ് എക്സിറ്റ് ഇവൻറുകൾക്കായി 1 തിരികെത്തരുന്നു,                       കൂടാതെ ചിസെലുകൾക്കുള്ളിൽ സിംഗിൾ ഇവൻറുകൾ എണ്ണുന്നതിന്                         ഉപയോഗിക്കാൻ കഴിയുകയും ചെയ്യും.
evt.around      (ഫിൽട്ടർ മാത്രം) ഇവൻറ് പ്രത്യേക സമയ ഇടവേളയിലാണെങ്കിലാണെങ്കിൽ                   സ്വീകരിക്കുന്നു. സിൻടാക്സ് evt.around[T]=D എന്നതാണ്, അതിൽ T എന്നത്                   ഇവൻറിനായി %evt.rawtime തിരികെത്തന്ന മൂല്യവും D എന്നത്                               മില്ലിസെക്കൻറിലുള്ള ഒരു ഡെൽറ്റയാണ്. ഉദാഹരണത്തിന്,                                   evt.around[1404996934793590564]=1000 എന്നത് ടൈംസ്റ്റാമ്പോട് കൂടിയ                         ഇവൻറുകൾ ടൈംസ്റ്റാമ്പിന് ഒരു സെക്കൻറ് മുൻപും ഒരു സെക്കൻറ് ശേഷവും                 തിരിച്ചുതരുന്നു, മൊത്തം രണ്ട് സെക്കൻറുള്ള കാപ്ചറിനായി.
evt.abspath     dirfd എന്നതിൽ നിന്നും കണക്കുകൂട്ടിയ കേവലമാർഗ്ഗവും, renameat,                         symlinkat എന്നിവ പോലുള്ള സിസ്കോളുകൾക്കിടയിലുള്ള പേരും.                           ഒന്നിലധികം മാർഗ്ഗങ്ങൾ പിന്തുണക്കുന്ന സിസ്കോളുകൾക്കായി                               'evt.abspath.src' അല്ലെങ്കിൽ 'evt.abspath.dst' ഉപയോഗിക്കുക.
evt.is_open_read
                വായിക്കാനായി ഓപ്പൺ ചെയ്ത മാർഗ്ഗങ്ങളുള്ള open/openat ഇവൻറുകൾക്ക്                     'true'
evt.is_open_write
                എഴുതാനായി ഓപ്പൺ ചെയ്ത മാർഗ്ഗങ്ങളുള്ള open/openat ഇവൻറുകൾക്ക്                       'true'
```

## `user` ഫീൽഡ് ക്ലാസ്സ്

ഉപയോക്താവ് ഇവൻറ് എക്സിക്ക്യൂട്ട് ചെയ്യുന്നതുമായി ബന്ധപ്പെട്ട ഫീൽഡുകൾ.

```
user.uid        ഉപയോക്തൃ ഐഡി.
user.name       ഉപയോക്തൃനാമം.
user.homedir    ഉപയോക്താവിൻറെ ഹോം ഡയറക്റ്ററി.
user.shell      ഉപയോക്താവിൻറെ ഷെൽ.
user.loginuid   ഓഡിറ്റ് ഉപയോക്തൃ ഐഡി(auid).
user.loginname  ഓഡിറ്റ് ഉപയോക്തൃനാമം (auid).
```

## `group` ഫീൽഡ് ക്ലാസ്സ്

ഇവൻറ് എക്സിക്ക്യൂട്ട് ചെയ്യുന്ന ഉപയോക്താവിൻറെ ഗ്രൂപ്പുമായി ബന്ധപ്പെട്ട ഫീൽഡുകൾ.

```
group.gid       ഗ്രൂപ്പ് ഐഡി.
group.name      ഗ്രൂപ്പ് നാമം.
```

## `syslog` ഫീൽഡ് ക്ലാസ്സ്

സിസ്ലോഗിലേക്കയ്കകുന്ന സന്ദേശങ്ങളുമായി ബന്ധപ്പെട്ട ഫീൽഡുകൾ.  സിസ്ലോഗ് സന്ദേശങ്ങളെ അടിസ്ഥാനമാക്കി നിയമങ്ങൾ നിർമ്മിക്കുന്നത് അനുവദിക്കുന്നു.

```
syslog.facility.str
                സ്ട്രിങ്ങ് രൂപത്തിലുള്ള സൌകര്യം.
syslog.facility സംഖ്യാരൂപത്തിലുള്ള സൌകര്യം(0-23).
syslog.severity.str
                സ്ട്രിങ്ങ് രൂപത്തിലുള്ള തീവ്രത. ഈ മൂല്യങ്ങളിലൊന്ന് ഉണ്ടാകാം: emerg, aler
                t, crit, err, warn, notice, info, debug
syslog.severity സംഖ്യാരൂപത്തിലുള്ള തീവ്രത(0-7).
syslog.message  സിസ്ലോഗിലേക്കയ്കകുന്ന സന്ദേശം.
```

## `container` ഫീൽഡ് ക്ലാസ്സ്

കണ്ടെയ്നറുകളുമായി ബന്ധപ്പെട്ട ഫീൽഡുകൾ.  `container.name`, `container.image`, മുതലായവയെ അടിസ്ഥാനമാക്കിയുള്ള ഫിൽട്ടറിങ് അനുവദിക്കുന്നു.
```
container.id    കണ്ടെയ്നർ ഐഡി.
container.name  കണ്ടെയ്നർ നാമം.
container.image കണ്ടെയ്നർ ചിത്രത്തിൻറെ പേര് (ഉദാ: ഡോക്കറിന് sysdig/sysdig:latest,).
container.image.id
                കണ്ടെയ്നർ ചിത്രത്തിൻറെ ഐഡി(ഉദാ: 6f7e2741b66b).
container.type  കണ്ടെയ്നർ തരം, ഉദാ: ഡോക്കർ അല്ലെങ്കിൽ rkt
container.privileged
                പ്രിവിലേജ്ഡ് ആയി റൺ ചെയ്യുന്ന കണ്ടെയ്നറുകൾക്ക് ട്രൂ, അല്ലാത്തവക്ക്                         ഫാൾസ്.
container.mounts
                മൌണ്ട് വിവരങ്ങളുടെ സ്പേസ് വേർതിരിച്ചുള്ള ലിസ്റ്റ്. ലിസ്റ്റിലെ ഓരോ                       ഇനത്തിനും <source>:<dest>:<mode>:<rdrw>:<propagation> എന്ന                             ഫോർമാറ്റാണുള്ളത്. 
container.mount ഒരൊറ്റ മൌണ്ടിനെ കുറിച്ചുള്ള വിവരങ്ങൾ, നമ്പർ വ്യക്തമാക്കിയത് (ഉദാ:                   container.mount[0]) അല്ലെങ്കിൽ മൌണ്ട് ഉറവിടം. (container.mount[/usr/local]).
                മാർഗ്ഗനാമം ഒരു glob ആകാം (container.mount[/usr/local/*]), അതിൽ                     പൊരുത്തപ്പെടുന്ന ആദ്യത്തെ മൌണ്ട് തിരിച്ചുവരും. വിവരങ്ങൾക്ക് <source>:                 <dest>:<mode>:<rdrw>:<propagation> എന്ന ഫോർമാറ്റാണുള്ളത്.വ്യക്തമാക്കിയ                 ഇൻഡെക്സോടെയുള്ളതോ ലഭ്യമായ ഉറവിടവുമായി പൊരുത്തപ്പെടുന്നതോ                   ആയ ഒരു മൌണ്ടും ഇല്ലെങ്കിൽ, ഒരു ശൂന്യമൂല്യത്തിന് പകരം "none" എന്ന                   സ്ട്രിങ്ങാവും തിരിച്ചുവരുന്നത്.
container.mount.source
                നമ്പർ വ്യക്തമാക്കിയ, മൌണ്ട് ഉറവിടം(ഉദാ: container.mount.source[0])                     അല്ലെങ്കിൽ മൌണ്ട് ലക്ഷ്യസ്ഥാനം(container.mount.source[/host/lib/modules                 ]).മാർഗ്ഗനാമം ഒരു glob ആകാം.
container.mount.dest
                നമ്പർ വ്യക്തമാക്കിയ, മൌണ്ട് ലക്ഷ്യസ്ഥാനം (ഉദാ:container.mount.dest[0])                 അല്ലെങ്കിൽ മൌണ്ട് ഉറവിടം (container.mount.dest[/lib/modules]).                         മാർഗ്ഗനാമം ഒരു glob ആകാം.
container.mount.mode
                നമ്പർ വ്യക്തമാക്കിയ, മൌണ്ട് മോഡ് (ഉദാ: container.mount.mode[0])                       അല്ലെങ്കിൽ മൌണ്ട് ഉറവിടം (container.mount.mode[/usr/local]).                           മാർഗ്ഗനാമം ഒരു glob ആകാം.
container.mount.rdwr
                നമ്പർ വ്യക്തമാക്കിയ, മൌണ്ട് rdwr മൂല്യം (ഉദാ: container.mount.rdwr[0])                 അല്ലെങ്കിൽ മൌണ്ട് ഉറവിടം (container.mount.rdwr[/usr/local]). മാർഗ്ഗനാമം                 ഒരു glob ആകാം.
container.mount.propagation
                നമ്പർ വ്യക്തമാക്കിയ, മൌണ്ട് പ്രചാരണമൂല്യം (ഉദാ:container.mount.                       propagation[0]) അല്ലെങ്കിൽ മൌണ്ട് ഉറവിടം (container.mount.propag
                ation[/usr/local]).  മാർഗ്ഗനാമം ഒരു glob ആകാം.
container.image.repository
                കണ്ടെയ്നർ ഇമേജ് റെപ്പോസിറ്ററി (ഉദാ: സിസ്ഡിഗ്/സിസ്ഡിഗ്).
container.image.tag
                കണ്ടെയ്നർ ഇമേജ് ടാഗ് (ഉദാ: stable, latest).
container.image.digest
                കണ്ടെയ്നർ ഇമേജ് രെജിസ്ട്രി ഡൈജസ്റ്റ് (ഉദാ: sha256:d977378f890d44
                5c15e51795296e4e5062f109ce6da83e0a355fc4ad8699d27).
container.healthcheck
                കണ്ടെയ്നറിൻറെ ആരോഗ്യപരിശോധന. ഒരു ആരോഗ്യപരിശോധനയും                         ക്രമീകരിച്ചിട്ടില്ലെങ്കിൽ ശൂന്യമൂല്യം ("N/A") എന്നതും, ക്രമീകരിച്ചിട്ടുണ്ട്                       എന്നാൽ വ്യക്തമായി സൃഷ്ടിച്ചിട്ടില്ലെങ്കിൽ "NONE" എന്നതും ആകും, കൂടാതെ                 മറിച്ചാണെങ്കിൽ ആരോഗ്യപരിശോധനാ കമാൻഡ് ലൈൻ.
```

## `k8s` ഫീൽഡ് ക്ലാസ്സ്

Kubernetes മെറ്റാഡാറ്റയിൽ ഫിൽട്ടർ ചെയ്യാനുള്ള ഫീൽഡുകൾ. പ്രത്യേക നെയിംസ്പേസുകളിലേക്ക് (`k8s.ns.name`)  അല്ലെങ്കിൽ ഉറവിടത്തിൻറെ ലേബലുകളിലേക്ക് നിയമങ്ങളെ പ്രയോഗിക്കാൻ അനുവദിക്കുന്നു. 

```
k8s.pod.name    Kubernetes പോഡ് നാമം.
k8s.pod.id      Kubernetes പോഡ് ഐഡി.
k8s.pod.label   Kubernetes പോഡ് ലേബൽ. ഉദാ: 'k8s.pod.label.foo'.
k8s.pod.labels  Kubernetes പോഡ് കോമയാൽ വേർതിരിച്ച കീ/മൂല്യം ലേബലുകൾ. ഉദാ:                     'foo1:bar1,foo2:bar2'.
k8s.rc.name     Kubernetes റെപ്ലിക്കേഷൻ കണ്ട്രോളർ നാമം.
k8s.rc.id       Kubernetes റെപ്ലിക്കേഷൻ കണ്ട്രോളർ ഐഡി.
k8s.rc.label    Kubernetes റെപ്ലിക്കേഷൻ കണ്ട്രോളർ ലേബൽ. ഉദാ:'k8s.rc.label.foo'.
k8s.rc.labels   Kubernetes റെപ്ലിക്കേഷൻ കണ്ട്രോളർ കോമയാൽ വേർതിരിച്ച കീ/മൂല്യം                     ലേബലുകൾ. ഉദാ: 'foo1:bar1,foo2:bar2'.
k8s.svc.name    Kubernetes സേവനനാമം (ഒന്നിൽ കൂടുതൽ മൂല്യങ്ങൾ സമാഹരിച്ച്                           തിരികെത്തരാൻ കഴിയുന്നു).
k8s.svc.id      Kubernetes സേവനഐഡി (ഒന്നിൽ കൂടുതൽ മൂല്യങ്ങൾ സമാഹരിച്ച്                         തിരികെത്തരാൻ കഴിയുന്നു)
k8s.svc.label   Kubernetes സേവനലേബൽ. ഉദാ: 'k8s.svc.label.foo' (ഒന്നിൽ കൂടുതൽ                   മൂല്യങ്ങൾ സമാഹരിച്ച് തിരികെത്തരാൻ കഴിയുന്നു).
k8s.svc.labels  Kubernetes സേവനം കോമയാൽ വേർതിരിച്ച കീ/മൂല്യം ലേബലുകൾ. ഉദാ:                   'foo1:bar1,foo2:bar2'.
k8s.ns.name     Kubernetes നെയിംസ്പേസ് നാമം.
k8s.ns.id       Kubernetes നെയിംസ്പേസ് ഐഡി.
k8s.ns.label    Kubernetes നെയിംസ്പേസ് ലേബൽ. ഉദാ: 'k8s.ns.label.foo'.
k8s.ns.labels   Kubernetes നെയിംസ്പേസ് കോമയാൽ വേർതിരിച്ച കീ/മൂല്യം ലേബലുകൾ.                 ഉദാ: 'foo1:bar1,foo2:bar2'.
k8s.rs.name     Kubernetes റെപ്ലിക്ക സെറ്റ് നാമം.
k8s.rs.id       Kubernetes റെപ്ലിക്ക സെറ്റ് ഐഡി.
k8s.rs.label    Kubernetes റെപ്ലിക്ക സെറ്റ് ലേബൽ. ഉദാ: 'k8s.rs.label.foo'.
k8s.rs.labels   Kubernetes റെപ്ലിക്ക സെറ്റ് കോമയാൽ വേർതിരിച്ച കീ/മൂല്യം ലേബലുകൾ.                   ഉദാ:'foo1:bar1,foo2:bar2'.
k8s.deployment.name
                Kubernetes വിന്യാസനാമം.
k8s.deployment.id
                Kubernetes വിന്യാസഐഡി.
k8s.deployment.label
                Kubernetes വിന്യാസലേബൽ. ഉദാ: 'k8s.rs.label.foo'.
k8s.deployment.labels
                Kubernetes വിന്യാസം കോമയാൽ വേർതിരിച്ച കീ/മൂല്യം ലേബലുകൾ. ഉദാ:                 'foo1:bar1,foo2:bar2'.
```

## `mesos` ഫീൽഡ് ക്ലാസ്സ്

ആപ്ലിക്കേഷൻ നാമം, ടാസ്ക് മുതലായവ പോലുള്ള മീസോസ്ഫിയർ മെറ്റാഡാറ്റയിൽ ഫിൽട്ടർ ചെയ്യാനുള്ള ഫീൽഡുകൾ.

```
mesos.task.name മീസോസ് ടാസ്ക് നാമം.
mesos.task.id   മീസോസ് ടാസ്ക് ഐഡി.
mesos.task.label
                മീസോസ് ടാസ്ക് ലേബൽ. ഉദാ: 'mesos.task.label.foo'.
mesos.task.labels
                മീസോസ് ടാസ്ക് കോമയാൽ വേർതിരിച്ച കീ/മൂല്യം ലേബലുകൾ. ഉദാ:                       'foo1:bar1,foo2:bar2'.
mesos.framework.name
                മീസോസ് ഫ്രെയിംവർക്ക് നാമം.
mesos.framework.id
                മീസോസ് ഫ്രെയിംവർക്ക് ഐഡി.
marathon.app.name
                മാരത്തോൺ ആപ്പ് നാമം.
marathon.app.id മാരത്തോൺ ആപ്പ് ഐഡി.
marathon.app.label
                മാരത്തോൺ ആപ്പ് ലേബൽ. ഉദാ: 'marathon.app.label.foo'.
marathon.app.labels
                മാരത്തോൺ ആപ്പ് കോമയാൽ വേർതിരിച്ച കീ/മൂല്യം ലേബലുകൾ. ഉദാ:                     'foo1:bar1,foo2:bar2'.
marathon.group.name
                മാരത്തോൺ ഗ്രൂപ്പ് നാമം.
marathon.group.id
                മാരത്തോൺ ഗ്രൂപ്പ് ഐഡി.
```

# Kubernetes ഓഡിറ്റ് ഇവൻറുകൾ (ഉറവിടം `k8s_audit`)

Kubernetes ഓഡിറ്റ് ഇവൻറ് ഫീൽഡുകൾ Kubernetes ഓഡിറ്റ് ഇവൻറ് ഉറവിടത്താൽ പിന്തുണച്ചതാണ്. കൂടുതൽ വിവരങ്ങൾക്ക് ദയവായി [Kubernetes Audit event source](../../event-sources/kubernetes-audit) ഡോക്യുമെൻറേഷൻ റഫർ ചെയ്യുക.

```
# Kubernetes ഓഡിറ്റ് ഇവൻറ് ഫീൽഡുകൾ
$ falco --list=k8s_audit
```

## `jevt` ഫീൽഡ് ക്ലാസ്സ്:  json ഇവൻറുകൾ ആക്സസ്സ് ചെയ്യാനുള്ള പൊതുവായ വഴികൾ
```
jevt.time       നാനോസെക്കൻറ് ഭാഗം ഉൾക്കൊള്ളുന്ന ഒരു സ്ട്രിങ്ങ് ആയ json ഇവൻറ്                     ടൈംസ്റ്റാമ്പ്
jevt.rawtime    കേവല ഇവൻറ് ടൈംസ്റ്റാമ്പ്, അതായത് ഇപക് മുതലുള്ള                                     നാനോസെക്കൻറുകൾ.
jevt.value      json ഓബ്ജക്റ്റിൽ നിന്നും ഒരൊറ്റ സവിശേഷത ആക്സസ്സ് ചെയ്യാനുള്ള                           പൊതുവായ വഴി. സിൻടാക്സ് [<json pointer expression>] എന്നതാണ്.                       സവിശേഷത ഒരു സ്ട്രിങ്ങായി തിരിച്ചുതരുന്നു.
jevt.obj        സ്ട്രിങ്ങാക്കിയ മുഴുവൻ json ഓബ്ജക്റ്റ്.
```

## `ka` ഫീൽഡ് ക്ലാസ്സ്: K8s ഓഡിറ്റ് ലോഗ് ഇവൻറുകൾ ആക്സസ് ചെയ്യുക
```
ka.auditid      ഓഡിറ്റ് ഇവൻറിൻറെ അദ്വിതീയമായ ഐഡി.
ka.stage        അഭ്യർത്ഥനയുടെ ഘട്ടം (ഉദാ: RequestReceived, ResponseComplete,                           മുതലായവ)
ka.auth.decision
                അംഗീകാരതീരുമാനം
ka.auth.reason  അംഗീകാരത്തിനുള്ള കാരണം
ka.user.name    അഭ്യർത്ഥന നടത്തുന്ന ഉപയോക്തൃനാമം
ka.user.groups  ഉപയോക്താവ് ഉൾപ്പെടുന്ന ഗ്രൂപ്പുകൾ
ka.impuser.name പ്രതിരൂപണം നടത്തിയ ഉപയോക്തൃനാമം
ka.verb         നടത്തപ്പെടുന്ന പ്രക്രിയ
ka.uri          ക്ലൈൻറിൽ നിന്നും സർവറിലേക്ക് അയച്ചതുപോലുള്ള അഭ്യർത്ഥനാ URI
ka.uri.param    uriയിൽ തന്നിരിക്കുന്ന അന്വേഷണപാരാമീറ്ററിൻറെ മൂല്യം(ഉദാ: uri=
                /foo?key=val, ka.uri.param[key] എന്നത് val ആകുമ്പോൾ).
ka.target.name  ലക്ഷ്യ ഓബ്ജക്റ്റ് നാമം
ka.target.namespace
                ലക്ഷ്യ ഓബ്ജക്റ്റ് നെയിംസ്പേസ്
ka.target.resource
                ലക്ഷ്യ ഓബ്ജക്റ്റ് വിഭവം
ka.target.subresource
                ലക്ഷ്യ ഓബ്ജക്റ്റ് ഉപവിഭവം
ka.req.binding.subjects
                അഭ്യർത്ഥനാഓബ്ജക്റ്റ് ക്ലസ്റ്റർ റോൾ ബൈൻഡിങ്ങിലേക്ക് റഫർ                               ചെയ്യുകയാണെങ്കിൽ, ബൈൻഡിങ്ങ് വഴി ബന്ധിപ്പിച്ചിരിക്കുന്ന സബ്ജക്റ്റ് (ഉദാ:                 അക്കൌണ്ട്/ഉപയോക്താക്കൾ).
ka.req.binding.subject.has_name
                അഭ്യർത്ഥനാഓബ്ജക്റ്റ് ക്ലസ്റ്റർ റോൾ ബൈൻഡിങ്ങിലേക്ക് റഫർ                               ചെയ്യുകയാണെങ്കിൽ, ലഭ്യമാക്കിയിട്ടുള്ള പേരിലുള്ള ഒരു സബ്ജക്റ്റ്                             നിലവിലുണ്ടെങ്കിൽ ട്രൂ ആയി തിരിച്ചുവരുന്നു.
ka.req.binding.role
                അഭ്യർത്ഥനാഓബ്ജക്റ്റ് ക്ലസ്റ്റർ റോൾ ബൈൻഡിങ്ങിലേക്ക് റഫർ                               ചെയ്യുകയാണെങ്കിൽ, ബൈൻഡിങ്ങ് വഴി ബന്ധിപ്പിച്ചിരിക്കുന്ന റോൾ
ka.req.configmap.name
                അഭ്യർത്ഥനാഓബ്ജക്റ്റ് ഒരു configmapലേക്കാണ് റഫർ ചെയ്യുന്നതെങ്കിൽ,                       configmap നാമം
ka.req.configmap.obj
                അഭ്യർത്ഥനാഓബ്ജക്റ്റ് ഒരു configmapലേക്കാണ് റഫർ ചെയ്യുന്നതെങ്കിൽ,                       മുഴുവൻ configmap പേര്
ka.req.container.image
                അഭ്യർത്ഥനാഓബ്ജക്റ്റ് ഒരു കണ്ടെയ്നറിലേക്കാണ് റഫർ ചെയ്യുന്നതെങ്കിൽ,                       കണ്ടെയ്നറിൻറെ ചിത്രങ്ങൾ. ഇൻഡക്സ് ചെയ്യാൻ കഴിയും (ഉദാ:                               ka.req.container.image[0]). ഒരു ഇൻഡക്സും ഇല്ലാതെ, ആദ്യത്തെ ചിത്രം                     തിരിച്ചുതരുന്നു.
ka.req.container.image.repository
                req.container.image പോലെ തന്നെ, പക്ഷേ റെപ്പോസിറ്ററി ഭാഗം മാത്രം                       (ഉദാ: സിസ്ഡിഗ്/ഫാൽക്കോ)
ka.req.container.host_network
                ഓബ്ജക്റ്റ് ഒരു കണ്ടെയ്നറിലേക്കാണ് റഫർ ചെയ്യുന്നതെങ്കിൽ, hostNetwork                       ഫ്ലാഗിൻറെ മൂല്യം.
ka.req.container.privileged
                ഓബ്ജക്റ്റ് ഒരു കണ്ടെയ്നറിലേക്കാണ് റഫർ ചെയ്യുന്നതെങ്കിൽ,ഏത് കണ്ടെയ്നറും                   പ്രിവിലേജ്ഡ് ആയിട്ടാണ് റൺ ചെയ്യുന്നതെങ്കിലും അല്ലെങ്കിലും.ഒരു ഇൻഡക്സ്                     ഉണ്ടാകുമ്പോൾ, ith കണ്ടെയ്നർ പ്രിവിലേജ്ഡ് ആയിട്ടാണ് റൺ ചെയ്യുന്നതെങ്കിലും                 അല്ലെങ്കിലും തിരിച്ചുവരുന്നു.
ka.req.role.rules
                അഭ്യർത്ഥനാഓബ്ജക്റ്റ് ഒരു റോൾ/ക്ലസ്റ്റർ റോളിലേക്കാണ് റഫർ                               ചെയ്യുന്നതെങ്കിൽ, റോളുമായി ബന്ധപ്പെട്ട നിയമങ്ങൾ
ka.req.role.rules.apiGroups
                അഭ്യർത്ഥനാഓബ്ജക്റ്റ് ഒരു റോൾ/ക്ലസ്റ്റർ റോളിലേക്കാണ് റഫർ                               ചെയ്യുന്നതെങ്കിൽ,റോളിൻറെ നിയമങ്ങളുമായി ബന്ധപ്പെട്ട api ഗ്രൂപ്പുകൾ. With an index, return
                ith നിയമത്തിൽ നിന്നുമുള്ള api ഗ്രൂപ്പുകൾ മാത്രം. ഇൻഡക്സ് ഇല്ലാത്ത, എല്ലാ                 ഗ്രൂപ്പുകളും സമാഹരിച്ച് തിരിച്ചുതരുന്നു
ka.req.role.rules.nonResourceURLs
                അഭ്യർത്ഥനാഓബ്ജക്റ്റ് ഒരു റോൾ/ക്ലസ്റ്റർ റോളിലേക്കാണ് റഫർ                               ചെയ്യുന്നതെങ്കിൽ,റോളിൻറെ നിയമങ്ങളുമായി ബന്ധപ്പെട്ട വിഭവമല്ലാത്ത urls.                 ഒരു ഇൻഡക്സ് ഉണ്ടാകുമ്പോൾ, ith നിയമത്തിൽ നിന്നും വിഭവമല്ലാത്ത urls                   മാത്രം തിരിച്ചുതരുന്നു. ഒരു ഇൻഡക്സ് ഇല്ലാത്തപ്പോൾ, വിഭവമല്ലാത്ത urls                     എല്ലാം സമാഹരിച്ച് തിരിച്ചുതരുന്നു.
ka.req.role.rules.verbs
                അഭ്യർത്ഥനാഓബ്ജക്റ്റ് ഒരു റോൾ/ക്ലസ്റ്റർ റോളിലേക്കാണ് റഫർ                               ചെയ്യുന്നതെങ്കിൽ, റോളിൻറെ നിയമങ്ങളുമായി ബന്ധപ്പെട്ട ക്രിയകൾ. ഒരു                   ഇൻഡക്സ് ഉണ്ടാകുമ്പോൾ, ith നിയമത്തിൽ നിന്നുമുള്ള ക്രിയകൾ മാത്രം                       തിരിച്ചുതരുന്നു. ഒരു ഇൻഡക്സ് ഇല്ലാത്തപ്പോൾ, ക്രിയകൾ എല്ലാം സമാഹരിച്ച്                   തിരിച്ചുതരുന്നു.
ka.req.role.rules.resources
                അഭ്യർത്ഥനാഓബ്ജക്റ്റ് ഒരു റോൾ/ക്ലസ്റ്റർ റോളിലേക്ക് റഫർ                                   ചെയ്യുമ്പോൾ, റോളിൻറെ നിയമങ്ങളുമായി ബന്ധപ്പെട്ട വിഭവങ്ങൾ. ഒരു                       ഇൻഡക്സ് ഉണ്ടാകുമ്പോൾ, ith നിയമത്തിൽ നിന്നുമുള്ള വിഭവങ്ങൾ മാത്രം                     തിരിച്ചുതരുന്നു.ഒരു ഇൻഡക്സ് ഇല്ലാത്തപ്പോൾ, വിഭവങ്ങൾ എല്ലാം സമാഹരിച്ച്                 തിരിച്ചുതരുന്നു.
ka.req.service.type
                അഭ്യർത്ഥനാഓബ്ജക്റ്റ് ഒരു സേവനത്തിലേക്ക് റഫർ ചെയ്യുമ്പോൾ, ആ                         സേവനതരം.
ka.req.service.ports
                അഭ്യർത്ഥനാഓബ്ജക്റ്റ് ഒരു സേവനത്തിലേക്ക് റഫർ ചെയ്യുമ്പോൾ, ആ                         സേവനത്തിൻറെ പോർട്ടുകൾ. ഇൻഡക്സ് ചെയ്യാനാകും (ഉദാ:                                 ka.req.service.ports[0]). ഒരു ഇൻഡക്സ് ഇല്ലാത്തപ്പോൾ എല്ലാ പോർട്ടുകളും                   തിരിച്ചുതരുന്നു.
ka.req.volume.hostpath
                അഭ്യർത്ഥനാഓബ്ജക്റ്റ് വോള്യം നിർവചനങ്ങൾ ഉൾക്കൊള്ളുന്നുണ്ടെങ്കിൽ,                     ഹോസ്റ്റിൽ നിന്നും (...hostpath[/etc]=true ഒരു വോള്യം ഹോസ്റ്റിൽ നിന്നും                   /etc എന്നത് മൌണ്ട് ചെയ്യുന്നുണ്ടെങ്കിൽ) വ്യക്തമാക്കിയ മാർഗ്ഗം മൌണ്ട്                     ചെയ്യുന്ന hostPath വോള്യം നിലവിലുണ്ടോ ഇല്ലയോ എന്നത്. ഇൻഡക്സ് ഒരു                     glob ആകാം, ആ സാഹചര്യത്തിൽ എല്ലാ വോള്യങ്ങളും ആ പ്രത്യേക glob                   ആയി പൊരുത്തപ്പെടുന്ന ഏതെങ്കിലും മാർഗ്ഗം കണ്ടുപിടിക്കുമെന്ന്                             കരുതുന്നു(...hostpath[/usr/*] ഒന്നുകിൽ /usr/local അല്ലെങ്കിൽ /usr/bin)                 ആയി പൊരുത്തപ്പെടുന്നു).
ka.resp.name    പ്രതികരണ ഓബ്ജക്റ്റ് നാമം
ka.response.code
                പ്രതികരണകോഡ്
ka.response.reason
                പ്രതികരണകാരണം (സാധാരണയായി പരാജയങ്ങൾക്ക് മാത്രം ഉണ്ടാകും)
```
