├── 60_oracle.py └── README.md /60_oracle.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | import urllib2 5 | import argparse 6 | import cx_Oracle 7 | import inspect 8 | import json 9 | import re 10 | import time 11 | import socket 12 | import re 13 | import commands 14 | import os 15 | import sys 16 | 17 | class Checks: 18 | 19 | def check_active(self): 20 | '''Check Intance is active and open''' 21 | sql = "select to_char(case when inst_cnt > 0 then 1 else 0 end,'FM99999999999999990') retvalue from (select count(*) inst_cnt from v$instance where status = 'OPEN' and logins = 'ALLOWED' and database_status = 'ACTIVE')" 22 | self.cur.execute(sql) 23 | res = self.cur.fetchall() 24 | for i in res: 25 | return i[0] 26 | 27 | def rcachehit(self): 28 | '''Read Cache hit ratio''' 29 | sql = "SELECT to_char((1 - (phy.value - lob.value - dir.value) / ses.value) * 100, 'FM99999990.9999') retvalue \ 30 | FROM v$sysstat ses, v$sysstat lob, \ 31 | v$sysstat dir, v$sysstat phy \ 32 | WHERE ses.name = 'session logical reads' \ 33 | AND dir.name = 'physical reads direct' \ 34 | AND lob.name = 'physical reads direct (lob)' \ 35 | AND phy.name = 'physical reads'" 36 | self.cur.execute(sql) 37 | res = self.cur.fetchall() 38 | for i in res: 39 | return i[0] 40 | 41 | def dsksortratio(self): 42 | '''Disk sorts ratio''' 43 | sql = "SELECT to_char(d.value/(d.value + m.value)*100, 'FM99999990.9999') retvalue \ 44 | FROM v$sysstat m, v$sysstat d \ 45 | WHERE m.name = 'sorts (memory)' \ 46 | AND d.name = 'sorts (disk)'" 47 | self.cur.execute(sql) 48 | res = self.cur.fetchall() 49 | for i in res: 50 | return i[0] 51 | 52 | def activeusercount(self): 53 | '''Count of active users''' 54 | sql = "select to_char(count(*)-1, 'FM99999999999999990') retvalue from v$session where username is not null \ 55 | and status='ACTIVE'" 56 | self.cur.execute(sql) 57 | res = self.cur.fetchall() 58 | for i in res: 59 | return i[0] 60 | 61 | def dbsize(self): 62 | '''Size of user data (without temp)''' 63 | sql = "SELECT to_char(sum( NVL(a.bytes - NVL(f.bytes, 0), 0)), 'FM99999999999999990') retvalue \ 64 | FROM sys.dba_tablespaces d, \ 65 | (select tablespace_name, sum(bytes) bytes from dba_data_files group by tablespace_name) a, \ 66 | (select tablespace_name, sum(bytes) bytes from dba_free_space group by tablespace_name) f \ 67 | WHERE d.tablespace_name = a.tablespace_name(+) AND d.tablespace_name = f.tablespace_name(+) \ 68 | AND NOT (d.extent_management like 'LOCAL' AND d.contents like 'TEMPORARY')" 69 | self.cur.execute(sql) 70 | res = self.cur.fetchall() 71 | for i in res: 72 | return i[0] 73 | 74 | def dbfilesize(self): 75 | '''Size of all datafiles''' 76 | sql = "select to_char(sum(bytes), 'FM99999999999999990') retvalue from dba_data_files" 77 | self.cur.execute(sql) 78 | res = self.cur.fetchall() 79 | for i in res: 80 | return i[0] 81 | 82 | def commits(self): 83 | '''User Commits''' 84 | sql = "select to_char(value, 'FM99999999999999990') retvalue from v$sysstat where name = 'user commits'" 85 | self.cur.execute(sql) 86 | res = self.cur.fetchmany(numRows=3) 87 | for i in res: 88 | return i[0] 89 | 90 | def rollbacks(self): 91 | '''User Rollbacks''' 92 | sql = "select to_char(value, 'FM99999999999999990') retvalue from v$sysstat where name = 'user rollbacks'" 93 | self.cur.execute(sql) 94 | res = self.cur.fetchall() 95 | for i in res: 96 | return i[0] 97 | 98 | def deadlocks(self): 99 | '''Deadlocks''' 100 | sql = "select to_char(value, 'FM99999999999999990') retvalue from v$sysstat where name = 'enqueue deadlocks'" 101 | self.cur.execute(sql) 102 | res = self.cur.fetchall() 103 | for i in res: 104 | return i[0] 105 | 106 | def redowrites(self): 107 | '''Redo Writes''' 108 | sql = "select to_char(value, 'FM99999999999999990') retvalue from v$sysstat where name = 'redo writes'" 109 | self.cur.execute(sql) 110 | res = self.cur.fetchall() 111 | for i in res: 112 | return i[0] 113 | 114 | def tblscans(self): 115 | '''Table scans (long tables)''' 116 | sql = "select to_char(value, 'FM99999999999999990') retvalue from v$sysstat where name = 'table scans (long tables)'" 117 | self.cur.execute(sql) 118 | res = self.cur.fetchall() 119 | for i in res: 120 | return i[0] 121 | 122 | def tblrowsscans(self): 123 | '''Table scan rows gotten''' 124 | sql = "select to_char(value, 'FM99999999999999990') retvalue from v$sysstat where name = 'table scan rows gotten'" 125 | self.cur.execute(sql) 126 | res = self.cur.fetchall() 127 | for i in res: 128 | return i[0] 129 | 130 | def indexffs(self): 131 | '''Index fast full scans (full)''' 132 | sql = "select to_char(value, 'FM99999999999999990') retvalue from v$sysstat where name = 'index fast full scans (full)'" 133 | self.cur.execute(sql) 134 | res = self.cur.fetchall() 135 | for i in res: 136 | return i[0] 137 | 138 | def hparsratio(self): 139 | '''Hard parse ratio''' 140 | sql = "SELECT to_char(h.value/t.value*100,'FM99999990.9999') retvalue \ 141 | FROM v$sysstat h, v$sysstat t \ 142 | WHERE h.name = 'parse count (hard)' \ 143 | AND t.name = 'parse count (total)'" 144 | self.cur.execute(sql) 145 | res = self.cur.fetchall() 146 | for i in res: 147 | return i[0] 148 | 149 | def netsent(self): 150 | '''Bytes sent via SQL*Net to client''' 151 | sql = "select to_char(value, 'FM99999999999999990') retvalue from v$sysstat where name = 'bytes sent via SQL*Net to client'" 152 | self.cur.execute(sql) 153 | res = self.cur.fetchall() 154 | for i in res: 155 | return i[0] 156 | 157 | def netresv(self): 158 | '''Bytes received via SQL*Net from client''' 159 | sql = "select to_char(value, 'FM99999999999999990') retvalue from v$sysstat where name = 'bytes received via SQL*Net from client'" 160 | self.cur.execute(sql) 161 | res = self.cur.fetchall() 162 | for i in res: 163 | return i[0] 164 | 165 | def netroundtrips(self): 166 | '''SQL*Net roundtrips to/from client''' 167 | sql = "select to_char(value, 'FM99999999999999990') retvalue from v$sysstat where name = 'SQL*Net roundtrips to/from client'" 168 | self.cur.execute(sql) 169 | res = self.cur.fetchall() 170 | for i in res: 171 | return i[0] 172 | 173 | def logonscurrent(self): 174 | '''Logons current''' 175 | sql = "select to_char(value, 'FM99999999999999990') retvalue from v$sysstat where name = 'logons current'" 176 | self.cur.execute(sql) 177 | res = self.cur.fetchall() 178 | for i in res: 179 | return i[0] 180 | 181 | def lastarclog(self): 182 | '''Last archived log sequence''' 183 | sql = "select to_char(max(SEQUENCE#), 'FM99999999999999990') retvalue from v$log where archived = 'YES'" 184 | self.cur.execute(sql) 185 | res = self.cur.fetchall() 186 | for i in res: 187 | return i[0] 188 | 189 | def lastapplarclog(self): 190 | '''Last applied archive log (at standby).Next items requires [timed_statistics = true]''' 191 | sql = "select to_char(max(lh.SEQUENCE#), 'FM99999999999999990') retvalue \ 192 | from v$loghist lh, v$archived_log al \ 193 | where lh.SEQUENCE# = al.SEQUENCE# and applied='YES'" 194 | self.cur.execute(sql) 195 | res = self.cur.fetchall() 196 | for i in res: 197 | return i[0] 198 | 199 | def freebufwaits(self): 200 | '''Free buffer waits''' 201 | sql = "select to_char(time_waited, 'FM99999999999999990') retvalue \ 202 | from v$system_event se, v$event_name en \ 203 | where se.event(+) = en.name and en.name = 'free buffer waits'" 204 | self.cur.execute(sql) 205 | res = self.cur.fetchall() 206 | for i in res: 207 | return i[0] 208 | 209 | def bufbusywaits(self): 210 | '''Buffer busy waits''' 211 | sql = "select to_char(time_waited, 'FM99999999999999990') retvalue \ 212 | from v$system_event se, v$event_name en \ 213 | where se.event(+) = en.name and en.name = 'buffer busy waits'" 214 | self.cur.execute(sql) 215 | res = self.cur.fetchall() 216 | for i in res: 217 | return i[0] 218 | 219 | def logswcompletion(self): 220 | '''log file switch completion''' 221 | sql = "select to_char(time_waited, 'FM99999999999999990') retvalue \ 222 | from v$system_event se, v$event_name en \ 223 | where se.event(+) = en.name and en.name = 'log file switch completion'" 224 | self.cur.execute(sql) 225 | res = self.cur.fetchall() 226 | for i in res: 227 | return i[0] 228 | 229 | def logfilesync(self): 230 | '''Log file sync''' 231 | sql = "select to_char(time_waited, 'FM99999999999999990') retvalue \ 232 | from v$system_event se, v$event_name en \ 233 | where se.event(+) = en.name and en.name = 'log file sync'" 234 | self.cur.execute(sql) 235 | res = self.cur.fetchall() 236 | for i in res: 237 | return i[0] 238 | 239 | def logprllwrite(self): 240 | '''Log file parallel write''' 241 | sql = "select to_char(time_waited, 'FM99999999999999990') retvalue \ 242 | from v$system_event se, v$event_name en \ 243 | where se.event(+) = en.name and en.name = 'log file parallel write'" 244 | self.cur.execute(sql) 245 | res = self.cur.fetchall() 246 | for i in res: 247 | return i[0] 248 | 249 | def enqueue(self): 250 | '''Enqueue waits''' 251 | sql = "select to_char(time_waited, 'FM99999999999999990') retvalue \ 252 | from v$system_event se, v$event_name en \ 253 | where se.event(+) = en.name and en.name = 'enqueue'" 254 | self.cur.execute(sql) 255 | res = self.cur.fetchall() 256 | for i in res: 257 | return i[0] 258 | 259 | def dbseqread(self): 260 | '''DB file sequential read waits''' 261 | sql = "select to_char(time_waited, 'FM99999999999999990') retvalue \ 262 | from v$system_event se, v$event_name en \ 263 | where se.event(+) = en.name and en.name = 'db file sequential read'" 264 | self.cur.execute(sql) 265 | res = self.cur.fetchall() 266 | for i in res: 267 | return i[0] 268 | 269 | def dbscattread(self): 270 | '''DB file scattered read''' 271 | sql="select to_char(time_waited, 'FM99999999999999990') retvalue \ 272 | from v$system_event se, v$event_name en \ 273 | where se.event(+) = en.name and en.name = 'db file scattered read'" 274 | self.cur.execute(sql) 275 | res = self.cur.fetchall() 276 | for i in res: 277 | return i[0] 278 | 279 | def dbsnglwrite(self): 280 | '''DB file single write''' 281 | sql="select to_char(time_waited, 'FM99999999999999990') retvalue \ 282 | from v$system_event se, v$event_name en \ 283 | where se.event(+) = en.name and en.name = 'db file single write'" 284 | self.cur.execute(sql) 285 | res = self.cur.fetchall() 286 | for i in res: 287 | return i[0] 288 | 289 | def dbprllwrite(self): 290 | '''DB file parallel write''' 291 | sql="select to_char(time_waited, 'FM99999999999999990') retvalue \ 292 | from v$system_event se, v$event_name en \ 293 | where se.event(+) = en.name and en.name = 'db file parallel write'" 294 | self.cur.execute(sql) 295 | res = self.cur.fetchall() 296 | for i in res: 297 | return i[0] 298 | 299 | def directread(self): 300 | '''Direct path read''' 301 | sql="select to_char(time_waited, 'FM99999999999999990') retvalue \ 302 | from v$system_event se, v$event_name en \ 303 | where se.event(+) = en.name and en.name = 'direct path read'" 304 | self.cur.execute(sql) 305 | res = self.cur.fetchall() 306 | for i in res: 307 | return i[0] 308 | 309 | def directwrite(self): 310 | '''Direct path write''' 311 | sql="select to_char(time_waited, 'FM99999999999999990') retvalue \ 312 | from v$system_event se, v$event_name en \ 313 | where se.event(+) = en.name and en.name = 'direct path write'" 314 | self.cur.execute(sql) 315 | res = self.cur.fetchall() 316 | for i in res: 317 | return i[0] 318 | 319 | def latchfree(self): 320 | '''latch free.''' 321 | sql="select to_char(time_waited, 'FM99999999999999990') retvalue \ 322 | from v$system_event se, v$event_name en \ 323 | where se.event(+) = en.name and en.name = 'latch free'" 324 | self.cur.execute(sql) 325 | res = self.cur.fetchall() 326 | for i in res: 327 | return i[0] 328 | 329 | 330 | def get_tablespaces_add_monitlist(self): 331 | sql = "SELECT tablespace_name FROM dba_tablespaces ORDER BY 1"; 332 | self.cur.execute(sql) 333 | res = self.cur.fetchall() 334 | for i in res: 335 | self.monit_keys.append(('TABLESPACE_%s'%i[0] , 'GAUGE')) 336 | 337 | def get_tablespaces_temp_add_monitlist(self): 338 | sql = "SELECT tablespace FROM V$TEMPSEG_USAGE group by tablespace ORDER BY 1"; 339 | self.cur.execute(sql) 340 | res = self.cur.fetchall() 341 | for i in res: 342 | self.monit_keys.append(('TABLESPACE_TEMP_%s'%i[0] , 'GAUGE')) 343 | 344 | def get_asm_add_monitlist(self): 345 | '''List als ASM volumes in a JSON like format for Zabbix use''' 346 | sql = "select NAME from v$asm_diskgroup_stat ORDER BY 1"; 347 | self.cur.execute(sql) 348 | res = self.cur.fetchall() 349 | for i in res: 350 | self.monit_keys.append(('ASMVOLUME_%s'%i[0] , 'GAUGE')) 351 | 352 | 353 | def tablespace(self,name): 354 | sql = '''SELECT df.tablespace_name "TABLESPACE", ROUND ( (df.bytes - SUM (fs.bytes)) * 100 / df.bytes, 2) "USED" FROM (SELECT TABLESPACE_NAME,BYTES FROM sys.sm$ts_free fs UNION ALL SELECT TABLESPACE_NAME,FREE_SPACE FROM DBA_TEMP_FREE_SPACE ) FS, (SELECT tablespace_name, SUM (bytes) bytes FROM sys.sm$ts_avail GROUP BY tablespace_name UNION ALL SELECT TABLESPACE_NAME, SUM(bytes) FROM SYS.DBA_TEMP_FILES GROUP BY tablespace_name ) df WHERE fs.tablespace_name(+) = df.tablespace_name AND df.tablespace_name = '{0}' GROUP BY df.tablespace_name,df.bytes ORDER BY 1'''.format(name) 355 | self.cur.execute(sql) 356 | res = self.cur.fetchall() 357 | for i in res: 358 | return i[1] 359 | 360 | def tablespace_temp(self,name): 361 | '''Query temporary tablespaces''' 362 | sql = '''SELECT round(sum(a.blocks*8192)*100/bytes,2) percentual FROM V$TEMPSEG_USAGE a, dba_temp_files b where tablespace_name='{0}' and a.tablespace=b.tablespace_name group by a.tablespace,b.bytes'''.format(name) 363 | self.cur.execute(sql) 364 | res = self.cur.fetchall() 365 | for i in res: 366 | return i[0] 367 | 368 | def asm_volume_use(self,name): 369 | sql = "select round(((TOTAL_MB-FREE_MB)/TOTAL_MB*100),2) from v$asm_diskgroup_stat where name = '{0}'".format(name) 370 | self.cur.execute(sql) 371 | res = self.cur.fetchall() 372 | for i in res: 373 | return i[0] 374 | 375 | def check_archive(self,archive): 376 | '''List archive used''' 377 | sql = "select trunc((total_mb-free_mb)*100/(total_mb)) PCT from v$asm_diskgroup_stat where name='{0}' ORDER BY 1".format(archive) 378 | self.cur.execute(sql) 379 | res = self.cur.fetchall() 380 | for i in res: 381 | return i[0] 382 | 383 | def query_lock(self): 384 | '''Query lock''' 385 | sql = "SELECT count(*) FROM gv$lock l WHERE block=1" 386 | self.cur.execute(sql) 387 | res = self.cur.fetchall() 388 | for i in res: 389 | return i[0] 390 | 391 | def query_redologs(self): 392 | '''Redo logs''' 393 | sql = "select COUNT(*) from v$LOG WHERE STATUS='ACTIVE'" 394 | self.cur.execute(sql) 395 | res = self.cur.fetchall() 396 | for i in res: 397 | return i[0] 398 | 399 | def query_rollbacks(self): 400 | '''Query Rollback''' 401 | sql = "select nvl(trunc(sum(used_ublk*4096)/1024/1024),0) from gv$transaction t,gv$session s where ses_addr = saddr" 402 | self.cur.execute(sql) 403 | res = self.cur.fetchall() 404 | for i in res: 405 | return i[0] 406 | 407 | def query_sessions(self): 408 | '''Query Sessions''' 409 | sql = "select count(*) from gv$session where username is not null and status='ACTIVE'" 410 | self.cur.execute(sql) 411 | res = self.cur.fetchall() 412 | for i in res: 413 | return i[0] 414 | 415 | def fra_use(self): 416 | '''Query the Fast Recovery Area usage''' 417 | sql = "select round((SPACE_LIMIT-(SPACE_LIMIT-SPACE_USED))/SPACE_LIMIT*100,2) FROM V$RECOVERY_FILE_DEST" 418 | self.cur.execute(sql) 419 | res = self.cur.fetchall() 420 | for i in res: 421 | return i[0] 422 | 423 | 424 | class Main(Checks): 425 | 426 | def __init__(self): 427 | self.username = 'xxx' 428 | self.password = 'xxx' 429 | self.address = '1.1.1.1' 430 | self.database = 'xxx' 431 | self.ip = socket.gethostname() 432 | self.step = 60 433 | self.timestamp = int(time.time()) 434 | self.monit_keys = [ 435 | ('check_active','GAUGE'), 436 | ('rcachehit','GAUGE'), 437 | ('dsksortratio','GAUGE'), 438 | ('activeusercount','GAUGE'), 439 | ('dbsize','GAUGE'), 440 | ('dbfilesize','GAUGE'), 441 | ('commits','GAUGE'), 442 | ('rollbacks','GAUGE'), 443 | ('deadlocks','GAUGE'), 444 | ('redowrites','GAUGE'), 445 | ('tblscans','GAUGE'), 446 | ('tblrowsscans','GAUGE'), 447 | ('indexffs','GAUGE'), 448 | ('hparsratio','GAUGE'), 449 | ('netroundtrips','GAUGE'), 450 | ('logonscurrent','GAUGE'), 451 | ('lastarclog','GAUGE'), 452 | ('lastapplarclog','GAUGE'), 453 | ('bufbusywaits','GAUGE'), 454 | ('logswcompletion','GAUGE'), 455 | ('logfilesync','GAUGE'), 456 | ('logprllwrite','GAUGE'), 457 | ('enqueue','GAUGE'), 458 | ('dbseqread','GAUGE'), 459 | ('dbscattread','GAUGE'), 460 | ('dbsnglwrite','GAUGE'), 461 | ('dbprllwrite','GAUGE'), 462 | ('directread','GAUGE'), 463 | ('directwrite','GAUGE'), 464 | ('latchfree','GAUGE'), 465 | ('query_lock','GAUGE'), 466 | ('query_redologs','GAUGE'), 467 | ('query_rollbacks','GAUGE'), 468 | ('query_sessions','GAUGE'), 469 | ('fra_use','GAUGE') 470 | ] 471 | 472 | def db_connect(self): 473 | self.db = cx_Oracle.connect('''{0}/{1}@{2}/{3}'''.format(self.username,self.password,self.address,self.database)) 474 | self.cur = self.db.cursor() 475 | 476 | def db_close(self): 477 | self.db.close() 478 | 479 | def main(self): 480 | p = [] 481 | try: 482 | self.db_connect() 483 | try: 484 | self.get_tablespaces_add_monitlist() 485 | self.get_tablespaces_temp_add_monitlist() 486 | self.get_asm_add_monitlist() 487 | finally: 488 | self.db_close() 489 | except Exception, err: 490 | print err 491 | 492 | for key,vtype in self.monit_keys: 493 | try: 494 | self.db_connect() 495 | if key == 'check_active': 496 | try: 497 | value = int(self.check_active()) 498 | except: 499 | value = 999 500 | elif key == 'rcachehit': 501 | try: 502 | value = round(self.rcachehit(),2) 503 | except: 504 | value = 999 505 | elif key == 'dsksortratio': 506 | try: 507 | value = round(self.dsksortratio(),2) 508 | except: 509 | value = 999 510 | elif key == 'activeusercount': 511 | try: 512 | value = int(self.activeusercount()) 513 | except: 514 | value = 999 515 | elif key == 'dbsize': 516 | try: 517 | value = int(self.dbsize()) 518 | except: 519 | value = 999 520 | elif key == 'dbfilesize': 521 | try: 522 | value = int(self.dbfilesize()) 523 | except: 524 | value = 999 525 | elif key == 'commits': 526 | try: 527 | value = int(self.commits()) 528 | except: 529 | value = 999 530 | elif key == 'rollbacks': 531 | try: 532 | value = int(self.rollbacks()) 533 | except: 534 | value = 999 535 | elif key == 'deadlocks': 536 | try: 537 | value = int(self.deadlocks()) 538 | except: 539 | value = 999 540 | elif key == 'redowrites': 541 | try: 542 | value = int(self.redowrites()) 543 | except: 544 | value = 999 545 | elif key == 'tblscans': 546 | try: 547 | value = int(self.tblscans()) 548 | except: 549 | value = 999 550 | elif key == 'tblrowsscans': 551 | try: 552 | value = int(self.tblrowsscans()) 553 | except: 554 | value = 999 555 | elif key == 'indexffs': 556 | try: 557 | value = int(self.indexffs()) 558 | except: 559 | value = 999 560 | elif key == 'hparsratio': 561 | try: 562 | value = round(self.hparsratio(),2) 563 | except: 564 | value = 999 565 | elif key == 'netroundtrips': 566 | try: 567 | value = int(self.netroundtrips()) 568 | except: 569 | value = 999 570 | elif key == 'logonscurrent': 571 | try: 572 | value = int(self.logonscurrent()) 573 | except: 574 | value = 999 575 | elif key == 'lastarclog': 576 | try: 577 | value = int(self.lastarclog()) 578 | except: 579 | value = 999 580 | elif key == 'lastapplarclog': 581 | try: 582 | value = int(self.lastapplarclog()) 583 | except: 584 | value = 999 585 | elif key == 'bufbusywaits': 586 | try: 587 | value = int(self.bufbusywaits()) 588 | except: 589 | value = 999 590 | elif key == 'logswcompletion': 591 | try: 592 | value = int(self.logswcompletion()) 593 | except: 594 | value = 999 595 | elif key == 'logfilesync': 596 | try: 597 | value = int(self.logfilesync()) 598 | except: 599 | value = 999 600 | elif key == 'logprllwrite': 601 | try: 602 | value = int(self.logprllwrite()) 603 | except: 604 | value = 999 605 | elif key == 'enqueue': 606 | try: 607 | if self.enqueue() == null: 608 | value = 0 609 | except: 610 | value = 999 611 | elif key == 'dbseqread': 612 | try: 613 | value = int(self.dbseqread()) 614 | except: 615 | value = 999 616 | elif key == 'dbscattread': 617 | try: 618 | value = int(self.dbscattread()) 619 | except: 620 | value = 999 621 | elif key == 'dbsnglwrite': 622 | try: 623 | value = int(self.dbsnglwrite()) 624 | except: 625 | value = 999 626 | elif key == 'dbprllwrite': 627 | try: 628 | value = int(self.dbprllwrite()) 629 | except: 630 | value = 999 631 | elif key == 'directread': 632 | try: 633 | value = int(self.directread()) 634 | except: 635 | value = 999 636 | elif key == 'directwrite': 637 | try: 638 | value = int(self.directwrite()) 639 | except: 640 | value = 999 641 | elif key == 'latchfree': 642 | try: 643 | value = int(self.latchfree()) 644 | except: 645 | value = 999 646 | elif key == 'query_lock': 647 | try: 648 | value = int(self.query_lock()) 649 | except: 650 | value = 999 651 | elif key == 'query_redologs': 652 | try: 653 | value = int(self.query_redologs()) 654 | except: 655 | value = 999 656 | elif key == 'query_rollbacks': 657 | try: 658 | value = int(self.query_rollbacks()) 659 | except: 660 | value = 999 661 | elif key == 'query_sessions': 662 | try: 663 | value = int(self.query_sessions()) 664 | except: 665 | value = 999 666 | elif key == 'fra_use': 667 | try: 668 | value = round((self.fra_use()),2) 669 | except: 670 | value = 999 671 | elif re.compile(ur'TABLESPACE_(\w+)').findall(key) !=[]: 672 | try: 673 | value = round((self.tablespace(re.compile(ur'TABLESPACE_(\w+)').findall(key)[0])),2) 674 | except: 675 | vlaue = 999 676 | elif re.compile(ur'TABLESPACE_TEMP_(\w+)').findall(key) !=[]: 677 | try: 678 | value = round((self.tablespace_temp(re.compile(ur'TABLESPACE_TEMP_(\w+)').findall(key)[0])),2) 679 | except: 680 | vlaue = 999 681 | elif re.compile(ur'ASMVOLUME_(\w+)').findall(key) !=[]: 682 | try: 683 | value = round((self.asm_volume_use(re.compile(ur'ASMVOLUME_(\w+)').findall(key)[0])),2) 684 | except: 685 | vlaue = 999 686 | except Exception, err: 687 | return 'err:',err 688 | i = { 689 | 'Metric': 'oracle.%s' % key, 690 | 'Endpoint': self.ip, 691 | 'Timestamp': self.timestamp , 692 | 'Step': self.step, 693 | 'Value': value, 694 | 'CounterType': vtype, 695 | 'TAGS': 'port=1521' 696 | } 697 | p.append(i) 698 | 699 | method = "POST" 700 | handler = urllib2.HTTPHandler() 701 | opener = urllib2.build_opener(handler) 702 | url = 'http://172.18.14.5:6060/api/push' 703 | request = urllib2.Request(url, data=json.dumps(p) ) 704 | request.add_header("Content-Type",'application/json') 705 | request.get_method = lambda: method 706 | try: 707 | pass 708 | connection = opener.open(request) 709 | except urllib2.HTTPError,e: 710 | connection = e 711 | 712 | if connection.code == 200: 713 | print connection.read() 714 | else: 715 | print '{"err":1,"msg":"%s"}' % connection 716 | 717 | # print json.dumps(p, sort_keys=True,indent=4) 718 | 719 | if __name__ == '__main__': 720 | proc = commands.getoutput(' ps -ef|grep %s|grep -v grep|wc -l ' % os.path.basename(sys.argv[0])) 721 | sys.stdout.flush() 722 | if int(proc) < 5: 723 | Main().main() 724 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Openfaclon-Oralce 2 | 3 | 1.监控项： 4 | self.monit_keys = [ 5 | ('check_active','GAUGE'), 6 | ('rcachehit','GAUGE'), 7 | ('dsksortratio','GAUGE'), 8 | ('activeusercount','GAUGE'), 9 | ('dbsize','GAUGE'), 10 | ('dbfilesize','GAUGE'), 11 | ('commits','GAUGE'), 12 | ('rollbacks','GAUGE'), 13 | ('deadlocks','GAUGE'), 14 | ('redowrites','GAUGE'), 15 | ('tblscans','GAUGE'), 16 | ('tblrowsscans','GAUGE'), 17 | ('indexffs','GAUGE'), 18 | ('hparsratio','GAUGE'), 19 | ('netroundtrips','GAUGE'), 20 | ('logonscurrent','GAUGE'), 21 | ('lastarclog','GAUGE'), 22 | ('lastapplarclog','GAUGE'), 23 | ('bufbusywaits','GAUGE'), 24 | ('logswcompletion','GAUGE'), 25 | ('logfilesync','GAUGE'), 26 | ('logprllwrite','GAUGE'), 27 | ('enqueue','GAUGE'), 28 | ('dbseqread','GAUGE'), 29 | ('dbscattread','GAUGE'), 30 | ('dbsnglwrite','GAUGE'), 31 | ('dbprllwrite','GAUGE'), 32 | ('directread','GAUGE'), 33 | ('directwrite','GAUGE'), 34 | ('latchfree','GAUGE'), 35 | ('query_lock','GAUGE'), 36 | ('query_redologs','GAUGE'), 37 | ('query_rollbacks','GAUGE'), 38 | ('query_sessions','GAUGE'), 39 | ('fra_use','GAUGE') 40 | ] 41 | 42 | 2.使用方法： 43 | username、password、address、databases换成自己线上的即可。 44 | 3.环境准备 45 | (1)需要安装cx_Oralce,地址https://qa.debian.org/watch/sf.php/cx-oracle,找到对应python版本下载安装 46 | (2)需要安装 oracle-instantclient-basic-10.2.0.4-1.x86_64.rpm oracle-instantclient-devel-10.2.0.4-1.x86_64.rpm这个10.2对应你的oracle版本 47 | --------------------------------------------------------------------------------