{"id":933,"date":"2010-07-08T00:00:00","date_gmt":"2010-07-08T00:00:00","guid":{"rendered":"https:\/\/test.simple-talk.com\/uncategorized\/gathering-perfmon-data-with-powershell\/"},"modified":"2021-08-24T13:40:27","modified_gmt":"2021-08-24T13:40:27","slug":"gathering-perfmon-data-with-powershell","status":"publish","type":"post","link":"https:\/\/www.red-gate.com\/simple-talk\/databases\/sql-server\/database-administration-sql-server\/gathering-perfmon-data-with-powershell\/","title":{"rendered":"Gathering Perfmon Data with Powershell"},"content":{"rendered":"
\n

I was reading an excellent article by Allen White\u00a0<\/strong>(Twitter<\/a>|Blog<\/a>) on Performance Data Gathering<\/a> (to which I give all the credit for inspiring this module), and that’s when a PowerShell apple fell on my head: “Why not make a function that facilitates this?<\/em>” As a DBA, one of my almost-daily tasks is to capture and analyze Perfmon counters. You may wonder to yourself, “but you can do that with the get-counter<\/strong> cmdlet in PowerShell 2.0.<\/em>“<\/p>\n

Yes you can, and it is very helpful. However, I need multiple counters, and the results displayed in line with all values separated by commas (which is usually used to facilitate insertion into SQL Server), and\u00a0that’s when get-counter<\/strong> gets a little trickier to use. I tried to think of an easy way to choose which counters you want, save this configuration for later use, and then insert the output data into a SQL Server table for further analysis. As a result of my tinkering, I believe I’ve got something pretty useful to share with you.<\/p>\n

Before I go on, I want to give a shout out to the people who helped me solve some issues I encountered; as always, my friend MVP Shay Levy<\/strong> (Twitter<\/a>|Blog<\/a>), and also MVP JVierra<\/strong> , Trevor Sullivan<\/strong> (Twitter<\/a>|Blog<\/a>), and Lauri Kotilainen<\/strong> (Twitter<\/a>|Blog<\/a>) . A special thank-you goes to MVP Pinal Dave <\/strong>(Twitter<\/a>|Blog<\/a>), who invited me to be a guest blogger on SQLAuthority.com<\/a>, and MVP Grant Fritchey<\/strong> (Twitter<\/a>|Blog<\/a>) for the kind words on his blog.<\/p>\n

This article will cover how to use this new module in a variety of situations, with some clear and every-day examples to hopefully make everything obvious. To start with, I’ll walk you through how to find out more information on the various Perfmon counters, so that you can choose which ones you want to use, as well as how to save that configuration so that you can reuse it later (and on different servers). Once we’ve covered that, we’ll take a look at how to get the data collected, and two ways to store it once we’ve got it.<\/p>\n

Performance Counters<\/h1>\n

A polished version of this whole module will be available in the next release of SQLPSX – SQL Server PowerShell Extensions<\/a>. For now, you can download it from the top of this article<\/a>, and I should point out that this module is a V1, so it might (and probably will) have some issues, and you can contact me anytime<\/a> if you need a hand. Alternatively, you can use the built-in help to see all of the parameters and some examples:<\/p>\n

Get-Help Get-PerfCounterCategory -examples<\/pre>\n
All tests were done on two Hyper-V 64-bit Virtual Machines;\u00a0 a Windows 2008 Server R2 domain controller with SQL Server 2008 R2 (Obiwan), and a Windows 7 machine with SQL Server 2008 (Chewie). Before you get started, if you want to work with multiple servers, you need to enable the RemoteRegistry Service in the remote machines , as you can see :<\/p>\n
\"1081-figure1.gif\"<\/p>\n
Figure 1.Ensuring the RemoteRegistry Service is active on the remote machines.<\/p>\n
For further reading on why this is necessary, I suggest you take a look at “Why run the RemoteRegistry Service?<\/a>” by Brian Groth.<\/p>\n
Top Tip:<\/strong> If you want to know which information (properties) are returned by a given functions, type: Function | get-member -membertype noteproperty.<\/strong> For example: Get-PerfCounterCategory<\/strong> | <\/strong>Get-Member<\/strong> -MemberType<\/em><\/strong> NoteProperty<\/strong><\/p>\n
Finding the Information<\/h1>\n
The thing that most bothered me at the start of this project was that, for some counters in Perfmon, I knew their names but could not remember exactly which category they were in. I’ll give you a few examples. Let’s say you remember that Buffer Cache Hit Ratio<\/strong> is in one of the SQL Server categories, but which one? We know that it’s painful to look in IDE for the answer, so now it’s much easier; if you want to discover all the registered categories, you can use this command:<\/p>\n
Get-PerfCounterCategory<\/pre>\n
Alternatively, if you want to be more fine-grained and only discover the categories starting with “SQLServer<\/em>“, ordering by Category Name, then use this command:<\/p>\n
Get-PerfCounterCategory -CategoryName \"SQLServer*\" | Sort-Object \r\nCategory_name | Format-list Machine_Name,Category_Name,Category_Type,\r\nCategory_Description <\/pre>\n
\"1081-figure2.gif\"<\/p>\n
Figure 2. Results for the Get-PerfCounterCategory cmdlet.<\/p>\n
Each Performance Counter category has a number of instances, or it can have just a single instance. For example, with the Processor Counter, you can have one instance for each processor, and with Buffer Manager you have only a single instance. You can see the information for, as an example, all instances in the Processor<\/strong> category by typing:<\/p>\n
Get-PerfCounterCategory -CategoryName \"PROCESSOR*\" | Get-PerfCounterInstance\r\n| Sort-Object Category_name | Format-list Machine_Name,Category_Name,\r\nInstance_name <\/pre>\n
What’s that I hear you ask? Can you get all counters in all instances and categories? Yes, of course you can… and with some help information about each counter, too:<\/p>\n
Get-PerfCounterCategory | Get-PerfCounterInstance | Get-PerfCounterCounters\u00a0\r\n| Format-List Machine_Name,Category_Name,Counter_Name,Counter_Type,\r\nCounter_Help <\/pre>\n
\"1081-figure3.gif\"<\/p>\n
Figure 3. All counters in all instances and categories, with information.<\/p>\n
How about if you want to see all the counters from Buffer Manager category? Just use:<\/p>\n
Get-PerfCounterCategory -CategoryName \"*Buffer Manager*\" | \r\nGet-PerfCounterInstance\u00a0| Get-PerfCounterCounters | Format-List \r\nMachine_Name,Category_Name,Counter_Name,Counter_Type,Counter_Help <\/pre>\n
And if I want to work with multiple servers? Simple, just pipe the servers names into the cmdlet:<\/p>\n
\"Obiwan\", \"Chewie\"| Get-PerfCounterCategory -CategoryName \"*Buffer Manager*\" \r\n| Get-PerfCounterInstance\u00a0| Get-PerfCounterCounters | Format-List \r\nMachine_Name,Category_Name,Counter_Name,Counter_Type,Counter_Help <\/pre>\n
… Or use a flat text file with the servers’ names inside it:<\/p>\n
Get-content servers.txt | Get-PerfCounterCategory -CategoryName \r\n\"*Buffer Manager*\" | Get-PerfCounterInstance\u00a0| Get-PerfCounterCounters | \r\nFormat-List Machine_Name,Category_Name,Counter_Name,Counter_Type,Counter_Help<\/pre>\n
As you can see , we can perform the search for missing information in various ways, facilitating the process of selecting the appropriate counters .<\/p>\n
Setting an XML Configure File<\/h1>\n
When I started writing this module, my big goal was that I should somehow be able to be mobile with the counters that I chose. That is, I should be able to save and then later use \u00a0the same configurations as easily within the original server as any another. After thinking about it, I decided that the gathering of data should start with reading an XML configuration file containing all the counters I’m interested in, and that I should have one file for memory counters, one for processor counters, and so on, to segment the data gathering .<\/p>\n
It seems like it might be a really complicated solution, especially when XML is involved, but thankfully it’s not too bad, as you’ll see in a moment. To start with, creating an XML file with all the counters from the Processor<\/strong> category and _Total<\/strong> instance is as simple as running:<\/p>\n
Get-PerfCounterCategory -CategoryName \"Processor*\" | Get-PerfCounterInstance\r\n -InstanceName \"_Total\" | Get-PerfCounterCounters | Save-ConfigPerfCounter\r\n -PathConfigFile c:\\temp\\TemplateProcessor.XML -NewFile <\/pre>\n
If you then look in your C:\\temp<\/em> folder, an XML file called TemplateProcessor_MACHINENAME.XML<\/strong> will be there, ready to be used.<\/p>\n
\n
Top Tip<\/strong> To facilitate the ability to identify and use multiple servers in your data-gathering process, the name of the target machine is added to the name of both the output file and the XML config file.<\/p>\n<\/div>\n
\"1081-1081-figure4A.gif\"<\/p>\n
Figure 4. Generating an XML file containing the Perfmon configuration<\/p>\n
As you can see, in this example I used the -NewFile<\/strong>switch parameter which, naturally, creates a new .XML file. Perhaps you’re wondering whether there are situations where I would not<\/em> use this parameter? Let’s say we have a file specifying just the Buffer Cache Hit Ratio<\/strong> counter from the Buffer Manager<\/strong> category:<\/p>\n
Get-PerfCounterCategory -CategoryName \"*Buffer Manager*\" | \r\nGet-PerfCounterInstance | Get-PerfCounterCounters -CounterName \r\n\"*cache hit ratio\" | Save-ConfigPerfCounter -PathConfigFile \r\nc:\\temp\\TemplateBufferManager.XML -NewFile <\/pre>\n
However, now we need to add the Page Life Expectancy<\/strong> counter to the already-existing file, so we just omit the\u00a0 -NewFile<\/strong>\u00a0 parameter, and the selected counters will be added to the XML file, rather than overwriting it:<\/p>\n
Get-PerfCounterCategory -CategoryName \"*Buffer Manager*\" | \r\nGet-PerfCounterInstance | Get-PerfCounterCounters -CounterName \"page life*\" \r\n| Save-ConfigPerfCounter -PathConfigFile c:\\temp\\TemplateBufferManager.XML<\/pre>\n
To create the configuration file in such a way that multiple servers can use it, we just need to specify the desired machines…<\/p>\n
\"ObiWan\", \"Chewie\" |\u00a0Get-PerfCounterCategory -CategoryName \r\n\"*Buffer Manager*\" | Get-PerfCounterInstance | Get-PerfCounterCounters | \r\nSave-ConfigPerfCounter -PathConfigFile c:\\temp\\BufferManager.XML -NewFile <\/pre>\n
… and a separate file will be created for each server<\/em>, using the name passed in the -PathConfigFile<\/strong> parameter \u00a0and adding the server name:<\/p>\n
\"1081-figure5.gif\"<\/p>\n
Figure 5. Creating configuration files for multiple servers.<\/p>\n
Gathering Data<\/h1>\n
With all that set up, the next step, starting to actually gather information, is a bit more complicated. Let’s take a look:<\/p>\n
To start with, the command below allows us to gather data using the counters defined in C:\\temp\\TemplateBufferManager_Obiwan.XML<\/em> , starting the collection job on 05\/24\/2010 08:00:00 AM, ending it on 05\/30\/2010 22:00:00 PM, with an interval of 10 seconds\u00a0 between each data collection, and outputting the values to C:\\temp\\ TemplateBufferManager.txt<\/em>:<\/p>\n
Set-CollectPerfCounter -DateTimeStart\u00a0\"05\/24\/2010 08:00:00\" -DateTimeEnd \r\n\"05\/30\/2010 22:00:00\" -Interval 10 -PathConfigFile \r\nc:\\temp\\TemplateBufferManager_Obiwan.XML\u00a0-PathOutputFile \r\nc:\\temp\\TemplateBufferManager.txt<\/pre>\n
When you run this command, you will notice that the PowerShell session will be locked; the function is in a loop to gather the data, and while this loop is running the session will be locked. Thankfully, we can resolve this by simply adding the -RunAsJob<\/strong>parameter, which tells PowerShell to perform this procedure asynchronously:<\/p>\n
Set-CollectPerfCounter -DateTimeStart\u00a0\"05\/24\/2010 08:00:00\" -DateTimeEnd \r\n\"05\/30\/2010 22:00:00\" -Interval 10 -PathConfigFile \r\nc:\\temp\\TemplateBufferManager_Obiwan.XML\u00a0-PathOutputFile\r\nc:\\temp\\TemplateBufferManager.txt -RunAsJob<\/pre>\n
As you may have guessed, this parameter creates a Job, and when you’re working with Jobs there are some things you have to take into consideration: \u00a0 The job created will be called “PERFCOUNTERS_” plus the name of the XML file and the current time (YYYYMMDDHHMMSS). In the case of my example, the name will be: PERFCOUNTERS_TemplateBufferManager_OBIWAN_20100306193300.<\/strong><\/p>\n
Of course, if you’re working with Jobs, then you’ll want to see which jobs are running:<\/p>\n
Get-job -state Running<\/pre>\n
To call the specific data-gathering Job, use ID or Name (which you have discovered using the command above):<\/p>\n
get-job -name PERFCOUNTERS_TemplateBufferManager_OBIWAN_20100306193300 | \r\nformat-list<\/pre>\n
To see if the job is running without errors, run the Receive-Job<\/strong>\u00a0 cmdlet, and heed Marco Shaw’s<\/strong> (Twitter<\/a> | Blog<\/a>) excellent advice:<\/p>\n
“… when using receive-job,<\/strong> one may want to use the switch parameter -keep<\/strong>. Otherwise, any associated output is lost if receive-job<\/strong> is run again.<\/em>“<\/p>\n
With the -keep<\/strong> parameter, the output is retained on the screen when you next run the receive-job<\/strong> cmdlet. So, with that in mind, our investigative command is now:<\/p>\n
get-job -name PERFCOUNTERS_TemplateBufferManager_OBIWAN_20100306193300 | \r\nreceive-job -keep<\/pre>\n
Alternatively, if we want to see all<\/em> jobs used by the PerfCounters Module, we just need to return all jobs starting with “PERFCOUNTERS…<\/em>“, so we can use where-object<\/strong> to find what we need:<\/p>\n
get-job -State running | Where-Object {$_.name -like \"PerfCounters*\"} <\/pre>\n
And finally, if I want to stop the job before the date set in the Set-CollectPerfCounter <\/strong>command, I just need to type:<\/p>\n
stop-job -name PERFCOUNTERS_TemplateBufferManager_OBIWAN_20100306193300 \r\nor\r\nstop-job -id <job id> (The Job ID can be found using Get-Job)<\/pre>\n
\"1081-figure6.gif\"<\/p>\n
Figure 6. Finding out what state the PerfCounter jobs are in.<\/p>\n
Uploading Data to a SQL Server Table<\/h1>\n
We can do this in one of two ways; the first method is bulk inserting the .txt file, and the other is, when the data is being gathered, to save it directly into a SQL Server Table. Let’s take a closer look:<\/p>\n
Bulk Inserting<\/h2>\n
After you’ve run your data-gathering job, you will see that the .txt file is ready to be inserted into SQL Server using a simple T-SQL bulk insert, and the Save-PerfCounterSQLTable<\/strong> function will help you do that. The command below will upload the output .txt file, and create a new table to receive the data (using -NewTable<\/strong> switch parameter):<\/p>\n
Save-PerfCounterSQLTable -ServerName Vader -DatabaseName Master\u00a0-NewTable\u00a0\r\n-PathConfigFile c:\\temp\\TemplateBufferManager_ObiWan.xml -PathOutputFile \r\nc:\\temp\\TemplateBufferManager.txt <\/pre>\n
Alternatively, if you want to upload the output .txt file into an existing Table, simply omit the -NewTable<\/strong> \u00a0switch parameter and pass the target table name in the -TableName<\/strong>parameter:<\/p>\n
Save-PerfCounterSQLTable -ServerName Vader -DatabaseName Master -TableName \r\nPerfCounterSQLTable_20100528100655\u00a0-PathConfigFile\u00a0\r\nc:\\temp\\TemplateBufferManager.xml -PathOutputFile\u00a0\r\nc:\\temp\\TemplateBufferManager.txt <\/pre>\n
If you prefer to have a bit more control of your tables, it’s a simple matter to combine the two previously mentioned switches to upload the .txt file and create a new table to receive it, with a name chosen by you :<\/p>\n
Save-PerfCounterSQLTable -ServerName Vader -DatabaseName Master -TableName \r\nMyTableName -NewTable\u00a0-PathConfigFile c:\\temp\\TemplateBufferManager.xml\r\n-PathOutputFile c:\\temp\\TemplateBufferManager.txt <\/pre>\n
As you may have noticed, the PathConfigFile<\/strong>\u00a0 and PathOutputFile<\/strong> parameters, which contain the full paths of the XML configuration file and output file respectively, are required. If you’d like to learn more about the Save-PerfCounterSQLTable<\/strong> command, use :<\/p>\n
Get-Help Save-PerfCounterSQLTable -full<\/pre>\n
Saving\u00a0 directly into SQL Server Table:<\/h2>\n
To best demonstrate this, let’s create a complete example. First, we choose the counters that we want to use. In case, this is the whole SQL Server Buffer Manager<\/strong> category on the Chewie and ObiWan machines, as well as the Processor<\/strong> category on Chewie. We save this configuration into C:\\temp\\BufferManager.XML and c:\\temp\\Processor.XML<\/em><\/p>\n
\"ObiWan\", \"Chewie\" |\u00a0Get-PerfCounterCategory -CategoryName \"*Buffer Manager*\"\r\n | Get-PerfCounterInstance | Get-PerfCounterCounters | Save-ConfigPerfCounter\r\n -PathConfigFile c:\\temp\\BufferManager.XML -NewFile \r\n\"Chewie\" |\u00a0Get-PerfCounterCategory -CategoryName \"Processor*\" | \r\nGet-PerfCounterInstance | Get-PerfCounterCounters | Save-ConfigPerfCounter \r\n-PathConfigFile c:\\temp\\Processor.XML -NewFile<\/pre>\n
\"1081-figure7.gif\"<\/p>\n
Figure 7. The demo configuration files for Obiwan and Chewie.<\/p>\n
Now, with the XML configured, we can now start the gathering of data using background Jobs and saving their output directly into a SQL Server Table. We do not pass the target SQL Server table name as a parameter, so one table will be created for each server, using the naming format of PERFCOUNTERS_XMLFileName_YYYYmmDDhhMMss<\/strong>. Even though you’re using a SQL Table as a data repository, you must<\/em> pass the path to an output file into your command, because the output file always will be created. Why, you ask? Let’s say you lose your connection to the SQL Server repository; this way, you don’t also lose the data, because it will also be stored in the .txt file. In this case, as we using several different XML files, we’ll only pass the target path, without the file name, and will be creating output files in this location using XMLNAME_MACHINENAME.TXT<\/strong> as a naming convention.<\/p>\n
dir \"c:\\temp\\*.Xml\" | Set-CollectPerfCounter\u00a0-DateTimeStart\u00a0\r\n\"05\/24\/2010 08:00:00\" -DateTimeEnd \"06\/30\/2010 22:00:00\" -Interval 10\u00a0\r\n-PathOutputFile c:\\temp\\ -ServerName ObiWan -DatabaseName Testes -NewTable \r\n-RunAsJob <\/pre>\n
\"1081-figure8.gif\"<\/p>\n
Figure 8. Creating the jobs to gather data, and sending the collected data directly to a SQL Server table.<\/p>\n
As you can see from figure 8, three jobs are created, and their names all start with PERFCOUNTER, so you can use where-object<\/strong> to quickly and easily find all jobs used by the PerfCounters Module:<\/p>\n
Get-Job -State Running | Where-Object { $_.name -like \"Perfcounter*\" } <\/pre>\n
Now, if we look in ObiWan’s SQL Server, we can see that there are three tables with the collected data: one for each machine we gathered data from (i.e. one for each XML file):<\/p>\n
\"1081-figure9.gif\"<\/p>\n
Figure 9. Investigating the gathered data in SQL Server.<\/p>\n
… And the .txt files containing the same gathered output are created as well:<\/p>\n
\"1081-figure10.gif\"<\/p>\n
Figure 10. The gathered data, stored in .txt files.<\/p>\n
When you’re setting this up, you can use your own table name to make things easy to find; I am passing the -TableName<\/strong> parameter with “BufferManager<\/strong>“, and so for each machine, a table called BufferManager_MACHINENAME<\/strong> will be created. In this case, BufferManager_Chewie<\/strong> and BufferManager_ObiWan<\/strong>:<\/p>\n
dir \"c:\\temp\\BufferManager*.Xml\" | Set-CollectPerfCounter\u00a0-DateTimeStart\u00a0\r\n\"05\/24\/2010 08:00:00\" -DateTimeEnd \"06\/30\/2010 22:00:00\" -Interval 10\u00a0\r\n-PathOutputFile c:\\temp\\BufferManager.txt -ServerName ObiWan -DatabaseName \r\nTests -NewTable -RunAsJob -TableName \"BufferManager\" <\/pre>\n
\"1081-figure11.gif\"<\/p>\n
Figure 11. Investigating the data stored in our custom-named tables.<\/p>\n
Perhaps you’re wondering why it’s so useful to be able to specify the target table name? Let’s say you stop the gathering, and want to continue on a completely different day, but outputting the data to the same table. Just Pass the -TableName<\/strong> parameter with the name of the original table, and don’t pass the -newtable<\/strong> switch parameter:<\/p>\n
Set-CollectPerfCounter\u00a0-PathConfigFile c:\\Temp\\BufferManager_Chewie.XML \r\n-DateTimeStart\u00a0\"05\/24\/2010 08:00:00\" -DateTimeEnd \"06\/30\/2010 22:00:00\" \r\n-Interval 10\u00a0-PathOutputFile c:\\temp\\BufferManager.txt -ServerName ObiWan \r\n-DatabaseName Testes\u00a0-RunAsJob -TableName \"BufferManager_Chewie\" <\/pre>\n
Remember, in this case you have to explicitly declare the XML file and, in the case of the code snippet above, I will restart the data gathering to Chewie, with C:\\temp\\BufferManager_Chewie.xml<\/em> as the configuration file, and the BufferManager_Chewie<\/strong> table as the SQL Server repository. The data is saved without creating a new table, and the output .txt file is always created as a data backup.<\/p>\n
In these examples I use Windows Authentication, but you can pass the Username and Password as parameters. If you get stuck at any point and want some more information, just type get-help <FunctionName>\u00a0 -examples<\/strong>.<\/p>\n
Well folks, I hope you can get some \u00a0good use out of this module, as I am. Once again, PowerShell wins.<\/p>\n
\n
Top Tip<\/strong><\/p>\n
When I was doing this article, I accidentally created 857 tables in SQL Server, and I had to drop them. Is that complicated? Not at all – here’s a hint:<\/p>\n
dir |% {$ _.drop ()}<\/code><\/p>\n
…where %<\/code> is an alias for a foreach-object. <\/strong><\/p>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
When you have to routinely collect  data from Performance Monitor Counters, it soon becomes easier and more convenient to use  PowerShell. SQL Server MVP Laerte Junior was inspired to create a script, and guides us through its useful functions.…<\/p>\n","protected":false},"author":221715,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[143527],"tags":[4170,4364,4782,4206,5243,4635,4150,4151],"coauthors":[6819],"class_list":["post-933","post","type-post","status-publish","format-standard","hentry","category-database-administration-sql-server","tag-database-administration","tag-monitoring","tag-perfmon","tag-performance","tag-performance-monitor","tag-powershell","tag-sql","tag-sql-server"],"acf":[],"_links":{"self":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/933","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/users\/221715"}],"replies":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/comments?post=933"}],"version-history":[{"count":9,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/933\/revisions"}],"predecessor-version":[{"id":74511,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/933\/revisions\/74511"}],"wp:attachment":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/media?parent=933"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/categories?post=933"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/tags?post=933"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/coauthors?post=933"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}