જેનકિન્સમાં એસક્યુએલ સર્વરનું ઓટોમેશન: પરિણામ સુંદર રીતે પરત કરવું

ફરી વ્યવસ્થાની થીમ ચાલુ રાખવી ઝીરો ટચ PROD આરડીએસ હેઠળ. ભાવિ DBAs PROD સર્વર્સ સાથે સીધું કનેક્ટ કરી શકશે નહીં, પરંતુ તેનો ઉપયોગ કરી શકશે જેનકિન્સ મર્યાદિત કામગીરી માટે નોકરીઓ. ડીબીએ નોકરી શરૂ કરે છે અને થોડા સમય પછી આ કામગીરી પૂર્ણ થવાના અહેવાલ સાથેનો પત્ર મેળવે છે. ચાલો આ પરિણામોને વપરાશકર્તા સમક્ષ રજૂ કરવાની રીતો જોઈએ.

સાદો ટેક્સ્ટ

ચાલો સૌથી તુચ્છ સાથે શરૂ કરીએ. પ્રથમ પદ્ધતિ એટલી સરળ છે કે તેના વિશે વાત કરવા માટે ખરેખર કંઈ નથી (લેખક હવે ફ્રીસ્ટાઇલ જોબ્સનો ઉપયોગ કરે છે):

sqlcmd કંઈક કરે છે અને અમે તેને વપરાશકર્તા સમક્ષ રજૂ કરીએ છીએ. ઉદાહરણ તરીકે, બેકઅપ નોકરીઓ માટે આદર્શ:

ભૂલશો નહીં, માર્ગ દ્વારા, RDS બેકઅપ/રીસ્ટોર હેઠળ અસુમેળ છે, તેથી તમારે તેની રાહ જોવાની જરૂર છે:

declare @rds table
  (id int, task_type varchar(128), database_name sysname, pct int, duration int, 
   lifecycle varchar(128), taskinfo varchar(max) null, 
   upd datetime, cre datetime,
   s3 varchar(256), ovr int, KMS varchar(256) null)
waitfor delay '00:00:20' 
insert into @rds exec msdb.dbo.rds_task_status @db_name='{db}'
select @xid=max(id) from @rds

again:
waitfor delay '00:00:02'
delete from @rds
insert into @rds exec msdb.dbo.rds_task_status @db_name='{db}' 
# {db} substituted with db name by powershell
select @stat=lifecycle,@info=taskinfo from @rds where id=@xid
if @stat not in ('ERROR','SUCCESS','CANCELLED') goto again

બીજી પદ્ધતિ, CSV

અહીં બધું પણ ખૂબ જ સરળ છે:

જો કે, આ પદ્ધતિ ફક્ત ત્યારે જ કાર્ય કરે છે જો CSV માં પરત કરવામાં આવેલ ડેટા "સરળ" હોય. જો તમે આ રીતે TOP N CPU સઘન ક્વેરીઝની સૂચિ પરત કરવાનો પ્રયાસ કરો છો, તો CSV એ હકીકતને કારણે "કરોડ" કરશે કે ક્વેરી ટેક્સ્ટમાં કોઈપણ અક્ષરો હોઈ શકે છે - અલ્પવિરામ, અવતરણ, અને રેખા વિરામ પણ. તેથી, અમને કંઈક વધુ જટિલની જરૂર છે.

HTML માં સુંદર ચિહ્નો

હું તમને તરત જ કોડ સ્નિપેટ આપીશ

$Header = @"
<style>
TABLE {border-width: 1px; border-style: solid; border-color: black; border-collapse: collapse;}
TH {border-width: 1px; padding: 3px; border-style: solid; border-color: black; background-color: #6495ED;}
TD {border-width: 1px; padding: 3px; border-style: solid; border-color: black;}
</style>
"@
  
$Result = invoke-Sqlcmd -ConnectionString $jstr -Query "select * from DbInv" `
  | Select-Object -Property * -ExcludeProperty "ItemArray", "RowError", "RowState", "Table", "HasErrors"
if ($Result -eq $null) { $cnt = 0; }
elseif ($Result.getType().FullName -eq "System.Management.Automation.PSCustomObject") { $cnt = 1; }
else { $cnt = $Result.Rows.Count; } 
if ($cnt -gt 0) {
  $body = "<h2>My table</h2>"
  $Result | ConvertTo-HTML -Title "Rows" -Head $header -body $body `
    | Out-File "res.log" -Append -Encoding UTF8
  } else {
    "<h3>No data</h3>" | Out-File "res.log" -Append -Encoding UTF8
  }

માર્ગ દ્વારા, System.Management.Automation.PSCustomObject સાથેની લાઇન પર ધ્યાન આપો, તે જાદુઈ છે; જો ગ્રીડમાં બરાબર એક લાઇન હોય, તો કેટલીક સમસ્યાઓ ઊભી થાય છે. બહુ સમજ્યા વગર ઈન્ટરનેટ પરથી ઉકેલ લેવામાં આવ્યો. પરિણામે, તમને આના જેવું કંઈક ફોર્મેટ આઉટપુટ મળશે:

આલેખ દોરવા

ચેતવણી: નીચે કિન્કી કોડ!
SQL સર્વર પર એક રમુજી ક્વેરી છે જે છેલ્લી N મિનિટ માટે CPU પ્રદર્શિત કરે છે - તે તારણ આપે છે કે કામરેજ મેજરને બધું યાદ છે! આ ક્વિઝ અજમાવી જુઓ:

DECLARE @ts_now bigint = (SELECT cpu_ticks/(cpu_ticks/ms_ticks) 
  FROM sys.dm_os_sys_info WITH (NOLOCK)); 
SELECT TOP(256) 
  DATEADD(ms, -1 * (@ts_now - [timestamp]), GETDATE()) AS [EventTime],
  SQLProcessUtilization AS [SQLCPU], 
  100 - SystemIdle - SQLProcessUtilization AS [OtherCPU]
FROM (SELECT record.value('(./Record/@id)[1]', 'int') AS record_id, 
  record.value('(./Record/SchedulerMonitorEvent/SystemHealth/SystemIdle)[1]', 'int') 
    AS [SystemIdle], 
  record.value('(./Record/SchedulerMonitorEvent/SystemHealth/ProcessUtilization)[1]', 'int') 
    AS [SQLProcessUtilization], [timestamp] 
  FROM (SELECT [timestamp], CONVERT(xml, record) AS [record] 
  FROM sys.dm_os_ring_buffers WITH (NOLOCK)
  WHERE ring_buffer_type = N'RING_BUFFER_SCHEDULER_MONITOR' 
    AND record LIKE N'%<SystemHealth>%') AS x) AS y 
ORDER BY 1 DESC OPTION (RECOMPILE);

હવે, આ ફોર્મેટિંગનો ઉપયોગ કરીને ($Fragment ચલ)

<table style="width: 100%"><tbody><tr style="background-color: white; height: 2pt;">
  <td style="width: SQLCPU%; background-color: green;"></td>
  <td style="width: OtherCPU%; background-color: blue;"></td>
  <td style="width: REST%; background-color: #C0C0C0;"></td></tr></tbody>
</table>

આપણે પત્રનો મુખ્ય ભાગ બનાવી શકીએ છીએ:

$Result = invoke-Sqlcmd -ConnectionString $connstr -Query $Query `
  | Select-Object -Property * -ExcludeProperty `
  "ItemArray", "RowError", "RowState", "Table", "HasErrors"
if ($Result.HasRows) {
  foreach($item in $Result) 
    { 
    $time = $itemEventTime 
    $sqlcpu = $item.SQLCPU
    $other = $itemOtherCPU
    $rest = 100 - $sqlcpu - $other
    $f = $fragment -replace "SQLCPU", $sqlcpu
    $f = $f -replace "OtherCPU", $other
    $f = $f -replace "REST", $rest
    $f | Out-File "res.log" -Append -Encoding UTF8
    }

જે આના જેવો દેખાશે:

હા, મહાશય વિકૃતિઓ વિશે ઘણું જાણે છે! તે રસપ્રદ છે કે આ કોડમાં શામેલ છે: પાવરશેલ (તેમાં લખાયેલ), SQL, Xquery, HTML. તે અફસોસની વાત છે કે અમે જાવાસ્ક્રિપ્ટને HTML માં ઉમેરી શકતા નથી (કારણ કે તે લખવા માટે છે), પરંતુ પાયથોન કોડને પોલિશ કરવો (જેનો ઉપયોગ SQL માં થઈ શકે છે) એ દરેકની ફરજ છે!

SQL પ્રોફાઇલર ટ્રેસ આઉટપુટ

તે સ્પષ્ટ છે કે TextData ફીલ્ડને કારણે ટ્રેસ CSV માં ફિટ થશે નહીં. પરંતુ પત્રમાં ટ્રેસ ગ્રીડ દર્શાવવું એ પણ વિચિત્ર છે - બંને કદને કારણે અને કારણ કે આ ડેટાનો ઉપયોગ વધુ વિશ્લેષણ માટે થાય છે. તેથી, અમે નીચે મુજબ કરીએ છીએ: અમે મારફતે કૉલ કરીએ છીએ invoke-SqlCmd ચોક્કસ સ્ક્રિપ્ટ, જેની ઊંડાઈમાં તે કરવામાં આવે છે

select 
  SPID,EventClass,TextData,
  Duration,Reads,Writes,CPU,
  StartTime,EndTime,DatabaseName,HostName,
  ApplicationName,LoginName
   from ::fn_trace_gettable ( @filename , default )  

આગળ, ચાલુ મિત્ર DBA દ્વારા ઍક્સેસ કરી શકાય તેવા સર્વર પર, ખાલી નમૂના સાથેનો એક ટ્રેસિસ ડેટાબેઝ છે, મોડેલ પ્લેટ, તમામ ઉલ્લેખિત કૉલમ સ્વીકારવા માટે તૈયાર છે. અમે આ મોડેલને અનન્ય નામ સાથે નવા ટેબલ પર કૉપિ કરીએ છીએ:

$dt = Get-Date -format "yyyyMMdd"
$tm = Get-Date -format "hhmmss"
$tableName = $srv + "_" + $dt + "_" + $tm
$copytab = "select * into " + $tableName + " from Model"
invoke-SqlCmd -ConnectionString $tstr -Query $copytab 

અને હવે આપણે તેનો ઉપયોગ કરીને આપણું ટ્રેસ લખી શકીએ છીએ ડેટા.SqlClient.SqlBulkCopy - મેં ઉપર આનું ઉદાહરણ પહેલેથી જ આપ્યું છે. હા, TextData માં સ્થિરાંકોને માસ્ક કરવું પણ સરસ રહેશે:

# mask data
foreach ($Row in $Result)
{ 
  $v = $Row["TextData"]
  $v = $v -replace "'([^']{2,})'", "'str'" -replace "[0-9][0-9]+", '999'
  $Row["TextData"] = $v
}

અમે એક અક્ષરથી વધુ લાંબી સંખ્યાઓને 999 સાથે બદલીએ છીએ, અને અમે એક અક્ષર કરતાં લાંબી સ્ટ્રિંગ્સને 'str' સાથે બદલીએ છીએ. 0 થી 9 સુધીની સંખ્યાઓનો વારંવાર ફ્લેગ તરીકે ઉપયોગ થાય છે, અને અમે તેમને સ્પર્શતા નથી, તેમજ ખાલી અને એક-અક્ષર શબ્દમાળાઓ - 'Y', 'N', વગેરે ઘણી વાર તેમની વચ્ચે જોવા મળે છે.

ચાલો આપણા જીવનમાં થોડો રંગ ઉમેરીએ (કડક 18+)

કોષ્ટકોમાં, તમે વારંવાર ધ્યાનની જરૂર હોય તેવા કોષોને પ્રકાશિત કરવા માંગો છો. ઉદાહરણ તરીકે, FAILS, ઉચ્ચ સ્તરનું વિભાજન, વગેરે. અલબત્ત, આ એકદમ એસક્યુએલમાં કરી શકાય છે, પ્રિન્ટનો ઉપયોગ કરીને HTML જનરેટ કરી શકાય છે અને જેનકિન્સમાં ફાઇલ પ્રકારને HTML પર સેટ કરી શકાય છે:

declare @body varchar(max), @chunk varchar(max)
set @body='<font face="Lucida Console" size="3">'
set @body=@body+'<b>Server name: '+@@servername+'</b><br>'
set @body=@body+'<br><br>'
set @body=@body+'<table><tr><th>Job</th><th>Last Run</th><th>Avg Duration, sec</th><th>Last Run, Sec</th><th>Last Status</th></tr>'
print @body

DECLARE tab CURSOR FOR SELECT '<tr><td>'+name+'</td><td>'+
  LastRun+'</td><td>'+
  convert(varchar,AvgDuration)+'</td><td>'+
  convert(varchar,LastDuration)+'</td><td>'+
    case when LastStatus<>'Succeeded' then '<font color="red">' else '' end+
      LastStatus+
      case when LastStatus<>'Succeeded' then '</font>' else '' end+
     +'</td><td>'
  from #j2
OPEN tab;  
FETCH NEXT FROM tab into @chunk
WHILE @@FETCH_STATUS = 0  
BEGIN
  print @chunk
  FETCH NEXT FROM tab into @chunk;  
END  
CLOSE tab;  
DEALLOCATE tab;
print '</table>'

મેં આવો કોડ કેમ લખ્યો?

પરંતુ ત્યાં એક વધુ સુંદર ઉકેલ છે. કન્વર્ટ ટુ-એચટીએમએલ અમને કોષોને રંગવા દેતા નથી, પરંતુ અમે તે હકીકત પછી કરી શકીએ છીએ. ઉદાહરણ તરીકે, અમે 80 થી વધુ અને 90 થી વધુના ફ્રેગમેન્ટેશન લેવલવાળા કોષો પસંદ કરવા માંગીએ છીએ. ચાલો શૈલીઓ ઉમેરીએ:

<style>
.SQLmarkup-red { color: red; background-color: yellow; }
.SQLmarkup-yellow { color: black; background-color: #FFFFE0; }
.SQLmarkup-default { color: black; background-color: white; }
</style>

ક્વેરી માં જ આપણે એક ડમી કોલમ ઉમેરીશું તરત જ પહેલાં કૉલમ અમે રંગ કરવા માંગો છો. કૉલમ બોલાવવી જોઈએ SQLમાર્કઅપ-કંઈક:

case  
  when ps.avg_fragmentation_in_percent>=90.0 then 'SQLmarkup-red'
  when ps.avg_fragmentation_in_percent>=80.0 then 'SQLmarkup-yellow'
  else 'SQLmarkup-default' 
  end as [SQLmarkup-1], 
ps.avg_fragmentation_in_percent, 

હવે, પાવરશેલ દ્વારા જનરેટ કરેલ HTML પ્રાપ્ત કર્યા પછી, અમે હેડરમાંથી ડમી કૉલમ દૂર કરીશું, અને ડેટાના મુખ્ય ભાગમાં અમે કૉલમમાંથી સ્ટાઈલમાં મૂલ્યને સ્થાનાંતરિત કરીશું. આ ફક્ત બે અવેજી સાથે કરવામાં આવે છે:

$html = $html `
  -replace "<th>SQLmarkup[^<]*</th>", "" `
  -replace "<td>SQLmarkup-(.+?)</td><td>",'<td class="SQLmarkup-$1">'

પરિણામ:


તે ભવ્ય નથી? ના હોવા છતાં, આ રંગ મને કંઈક યાદ અપાવે છે


સોર્સ: www.habr.com