Um desdes desafios, e um dos mais interessantes para mim, foi a missão de criar um sistema de auditoria para tabelas de bancos de dados utilizando o PostgreSQL.

Claro, nunca fui um DBA, e trabalhando com Banco de Dados nunca fui além da instalação/configuração de SGBDs para desenvolvimento de aplicações.  Mas tarefa dada é tarefa cumprida.

Então foi ai que me deparei com alguns problemas.

Em primeiro lugar, claro que não iria reinventar a roda caso ela já estivesse pronta. Então parti para buscas por soluções que pudessem me atender ou pelo menos me ajudar em parte. Então encontrei algumas interessantes e que serviriam apenas para
fins didáticos, outras que não eram nem um pouco interessantes e outras que me serviram bem, claro que com algumas melhorias
e adaptações.

No fim a solução que me atendeu segue os seguintes critérios:

1. A trigger deverá ser executada após cada INSERT, UPDATE e DELETE.
2. Deverá ser inserido na tabela de auditoria em uma única linha todas as ações que ocorreram na transação.
3. Deverá ser gravado na tabela de auditoria os dados: usuário que fez a ação, ip da máquina que fez a ação, nome da tabela, chave da tabela, valor da chave da tabela, host onde se encontra o banco de dados, nome do banco, nome do esquema, data/hora da ação, campos da tabela, tipo da ação (INSERT, UPDATE ou DELETE),  dados antigos da tabela e dados novos da tabela.
4. Deverá dar suporte a tabelas com chaves compostas.

O sistema está em testes no momento e tem apresentado bons resultados. Claro que poderá ser melhorado no futuro e o próximo passo será a criação de um sistema web em que eu possa visualizar/gerenciar as informações de auditoria.

OBS[1]: A linguagem utilizada neste sistema foi a PLPGSQL então se no servidor banco ainda não estiver com esta linguagem instalada deve-se instalar o pacote correspondente da versão do banco.
Ex. postgresql-plpgsql-9.1

OBS[2]:  Ainda para se utilizar as trigger no banco de dados, de acordo com cada linguagem deve-se habilitar o uso da respectiva
linguagem no banco com o seguinte comando:

createlang -U nome_usuario plpgsql nome_banco_de_dados 

Segue o esquema que foi criado para me atender:

1 – Tabela de Auditoria

 CREATE SEQUENCE auditoria_pkyaud_seq
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 2
  CACHE 1;
ALTER TABLE auditoria_pkyaud_seq OWNER TO grupoddl;
GRANT ALL ON TABLE auditoria_pkyaud_seq TO grupoddl;
GRANT ALL ON TABLE auditoria_pkyaud_seq TO grupodml;

CREATE TABLE auditoria -- tabela auditoria
(
  pkyaud bigint NOT NULL DEFAULT nextval('auditoria_pkyaud_seq'::regclass),       -- chave da tabela
  dthaud timestamp with time zone, -- data hora da ação
  usuaud character varying(30),    -- usuario da ação
  hosaud character varying(30),    -- Host onde se encontra o banco de dados
  banaud character varying(30),    -- banco de dados onde ocorreu a ação
  scmaud text[],                   -- schema onde ocorreu a ação
  tabaud character varying(30),    -- tabela onde ocorreu a ação
  camaud text,                     -- campos da tabela
  npkaud character varying(30)[],  -- nome da chave primaria da tabela auditada onde ocorreu a ação
  vpkaud character varying(60)[],  -- valor da chave primaria da tabela auditada onde ocorreu a ação
  tacaud character(6),             -- Tipo da ação ocorrida na tabela (insert, update ou delete)
  maqaud character varying(40),    -- ip da máquina que fez a ação
  vanaud text,                     -- valor antigo da tabela
  vnoaud text,                     -- valor novo da tabela
  queaud text,                     -- query executada durante a ação 

  CONSTRAINT auditoria_pkey PRIMARY KEY (pkyaud),
  CONSTRAINT auditoria_check_pk CHECK (array_length(npkaud, 1) = array_length(vpkaud, 1))
)
WITH (
  OIDS=FALSE
);

ALTER TABLE auditoria OWNER TO grupoddl;
GRANT ALL ON TABLE auditoria TO grupoddl;
GRANT ALL ON TABLE auditoria TO grupodml;

COMMENT ON TABLE  auditoria           IS 'Tabela de auditoria para tabelas dos sistemas';
COMMENT ON COLUMN auditoria.pkyaud    IS 'Chave primária sequencial da tabela';
COMMENT ON COLUMN auditoria.dthaud    IS 'Data Hora da ação';
COMMENT ON COLUMN auditoria.usuaud    IS 'Usuário que praticou a ação';
COMMENT ON COLUMN auditoria.hosaud    IS 'Host onde se encontra o banco de dados';
COMMENT ON COLUMN auditoria.banaud    IS 'Banco de Dados onde ocorreu a ação';
COMMENT ON COLUMN auditoria.scmaud    IS 'Schema onde ocorreu a ação';
COMMENT ON COLUMN auditoria.tabaud    IS 'Tabela onde ocorreu a ação';
COMMENT ON COLUMN auditoria.camaud    IS 'Campos da tabela';
COMMENT ON COLUMN auditoria.npkaud    IS 'Nome da Chave Primaria da tabela auditada onde ocorreu a ação';
COMMENT ON COLUMN auditoria.vpkaud    IS 'Valor da Chave Primaria da tabela auditada onde ocorreu a ação';
COMMENT ON COLUMN auditoria.tacaud    IS 'Tipo da ação ocorrida na tabela (INSERT, UPDATE ou DELETE)';
COMMENT ON COLUMN auditoria.maqaud    IS 'IP da máquina que praticou a ação';
COMMENT ON COLUMN auditoria.vanaud    IS 'Valor Antigo da tabela';
COMMENT ON COLUMN auditoria.vnoaud    IS 'Valor Novo da tabela';
COMMENT ON COLUMN auditoria.queaud    IS 'Query executada durante a ação';

2 – Foi criada uma função para ser utilizada pela trigger e fazer o assert (checagem) em alguns campos:

 CREATE OR REPLACE FUNCTION assert(BOOLEAN, CHARACTER VARYING)
  RETURNS void AS
$BODY$
BEGIN
 IF NOT $1 OR $1 IS NULL THEN
   IF $2 IS NOT NULL THEN
     RAISE EXCEPTION 'Assert failure: %', $2;
   END IF;
   RAISE NOTICE 'Assert. Message is null';
 END IF;
END;$BODY$
  LANGUAGE 'plpgsql' VOLATILE;

3 – Segue então a parte principal. A trigger que fará todo o processo de auditoria nas tabelas.

CREATE OR REPLACE FUNCTION log_to_auditoria() RETURNS TRIGGER AS
$BODY$
DECLARE
    _DTHAUD     timestamp;     -- data hora da ação
    _USUAUD     name;          -- usuario da ação
    _HOSAUD     inet;          -- Host onde se encontra o banco de dados 
    _BANAUD     name;          -- banco de dados onde ocorreu a ação
    _SCHAUD     VARCHAR[];     -- schema onde ocorreu a ação
    _TABAUD     name;          -- tabela onde ocorreu a ação
    _CAMAUD     text;          -- campos da tabela 
    _TACAUD     text;          -- Tipo da ação ocorrida na tabela (insert, update ou delete)
    _MAQAUD     inet;          -- ip da máquina que fez a ação
    _VNOAUD     text;          -- valor novo do campo afetado 
    _VANAUD     text;          -- valor antigo do campo afetado
    _QUEAUD     text;          -- query executada durante a ação     

      --pega os nomes das chaves primarias e coloca dentro de um array.
     _PK_NAMES CONSTANT VARCHAR[] := ARRAY(SELECT a.attname AS pk_name FROM pg_class c, pg_attribute a,                                                                                                pg_index i
     WHERE c.oid = i.indrelid
     AND a.attrelid = i.indexrelid
     AND a.attisdropped = FALSE
     AND a.attnum > 0
     AND i.indisprimary = TRUE
     AND c.oid = TG_RELID); 

     --pega o nome dos campos da tabela e coloca dentro de um array
    _FIELD_NAMES CONSTANT VARCHAR[] := ARRAY(SELECT a.attname AS pk_name FROM pg_class c, pg_attribute a
     WHERE c.oid = a.attrelid
     AND a.attisdropped = FALSE
     AND a.attnum > 0
     AND c.oid = TG_RELID ); 

    _PK_VALUES VARCHAR[]; 

    BEGIN  

    --utiliza a função assert para checar que a trigger será executada apenas após as ações
    PERFORM assert(TG_WHEN = 'AFTER', 'Wrong execution of fnc_audit(): should only be executed AFTER an event!');
    --utiliza a função assert para checar que a trigger será executada por cada linha
    PERFORM assert(TG_LEVEL = 'ROW', 'Wrong execution of fnc_audit(): should only be executed FOR EACH ROW!');
    --utiliza a função assert para checar que o nome da tabela não está nulo
    PERFORM assert(TG_TABLE_NAME IS NOT NULL, 'TG_TABLE_NAME IS NULL');
    --utiliza a função assert para chegar se a tabela possui chaves primárias. Não pode ser nulo.
    PERFORM assert(_PK_NAMES IS NOT NULL AND array_length(_PK_NAMES, 1) IS NOT NULL, 'Table ' ||
TG_TABLE_NAME || ' can not be logged: it has no PK!');   

    --Se por acidente a trigger for atribuida a própria tabela de auditoria finaliza sem fazer nada.
    IF TG_TABLE_NAME = 'auditoria' THEN
    RETURN NULL;
    END IF; 

    _DTHAUD := current_timestamp;  --pega a data/hora atual
    _MAQAUD := inet_client_addr(); --pega o ip da máquina que praticou a ação
    _USUAUD := current_user;       --pega o usuário que praticou a ação
    _HOSAUD := inet_server_addr(); --pega o ip do servidor onde está o banco de dados
    _BANAUD := current_database(); --pega o nome do banco de dados
    _SCHAUD := ARRAY(SELECT schemaname AS esquema FROM pg_catalog.pg_tables
WHERE tablename =   TG_TABLE_NAME AND schemaname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
                ORDER BY schemaname); --pega o nome do schema onde a tabela que está sendo auditada está
    _TABAUD := TG_TABLE_NAME; --pega o nome da tabela
    _CAMAUD := (SELECT string_agg(column_name,',') FROM information_schema.columns
WHERE table_name = TG_RELNAME); --pega o nome dos campos da tabela
    _TACAUD := TG_OP; --pega a ação executada (INSERT, UPDATE ou DELETE)
    _QUEAUD := (SELECT current_query()); --pega a query executada    

 --pega os valores das chaves primárias
FOR i IN 1 .. array_length(_PK_NAMES, 1)
LOOP
 DECLARE
  tmp text;
  tmp_record record;
 BEGIN
  CASE TG_OP
  WHEN 'UPDATE', 'INSERT' THEN tmp_record = NEW;
  WHEN 'DELETE' THEN tmp_record = OLD;
  END CASE; 

  EXECUTE 'SELECT $1.' || quote_ident(_PK_NAMES[i]) INTO STRICT tmp USING tmp_record;
  _PK_VALUES[i] := tmp;
 END;
END LOOP;   

--utiliza a função assert para checar se os valores das chaves primárias não são nulos. PERFORM assert(_PK_VALUES IS NOT NULL AND array_length(_PK_VALUES, 1) IS NOT NULL, '_PK_VALUES IS NULL');

--utiliza a função assert para checar se está correta a mesma quantidade de nomes e valores de chaves primárias. PERFORM assert(array_length(_PK_VALUES, 1) = array_length(_PK_NAMES, 1), '_PK_VALUES
count not equal to _PK_NAMES count in table ' || TG_TABLE_NAME); 

       --insere os dados coletados de acordo com a ação executada
       IF (TG_OP = 'INSERT') THEN   

            INSERT INTO auditoria(dthaud, usuaud, hosaud, banaud, scmaud, tabaud, camaud, npkaud, vpkaud,
tacaud, maqaud, vanaud, vnoaud, queaud)
                        VALUES (_DTHAUD, _USUAUD, _HOSAUD::text, _BANAUD::text, _SCHAUD, _TABAUD, _CAMAUD,
_PK_NAMES, _PK_VALUES, _TACAUD, _MAQAUD, NULL, NEW, _QUEAUD);
            RETURN NEW;
        ELSIF (TG_OP = 'UPDATE') THEN    

            INSERT INTO auditoria(dthaud, usuaud, hosaud, banaud, scmaud, tabaud, camaud, npkaud, vpkaud,
tacaud, maqaud, vanaud, vnoaud, queaud)
                        VALUES (_DTHAUD, _USUAUD, _HOSAUD::text, _BANAUD::text, _SCHAUD, _TABAUD, _CAMAUD,
_PK_NAMES, _PK_VALUES, _TACAUD, _MAQAUD, OLD, NEW, _QUEAUD);
            RETURN NEW;
        ELSIF (TG_OP = 'DELETE') THEN        

            INSERT INTO auditoria(dthaud, usuaud, hosaud, banaud, scmaud, tabaud, camaud, npkaud, vpkaud,
tacaud, maqaud, vanaud, vnoaud, queaud)
                        VALUES (_DTHAUD, _USUAUD, _HOSAUD::text, _BANAUD::text, _SCHAUD, _TABAUD, _CAMAUD,
_PK_NAMES, _PK_VALUES, _TACAUD, _MAQAUD, OLD, NULL, _QUEAUD);
            RETURN OLD;
        END IF;
        RETURN NULL; -- o resultado é ignorado uma vez que este é um gatilho AFTER
    END; 

$BODY$
LANGUAGE plpgsql VOLATILE STRICT;

ALTER FUNCTION log_to_auditoria() OWNER TO sistemadba;      -- atribuindo o usuário como dono da trigger
GRANT EXECUTE ON FUNCTION log_to_auditoria() TO sistemadba; -- usuário dono do banco
GRANT EXECUTE ON FUNCTION log_to_auditoria() TO grupoddl;

4 – Feito isso, para cada tabela que se deseja autitar basta executar o comando abaixo:

CREATE TRIGGER log_to_auditoria_nome_da_tabela_auditada

  AFTER INSERT OR UPDATE OR DELETE
  ON nome_da_tabela_auditada
  FOR EACH ROW
  EXECUTE PROCEDURE log_to_auditoria();

Bem, conforme informado acima, este sistema de auditoria ainda está em testes mas até o momento parece funcionar bem. Da forma utilizada aqui pode se utilizar sem precisar fazer nennhuma alteração na estrutura, bastando apenas modificar a tabela auditoria que receberá os dados e os respectivos inserts.

A versão do PostgreSQL utilizada foi a 9.1 e as fontes utilizadas para pesquisa/consulta e como base foram:

[1]http://www.postgresql.org/docs/9.1/static/functions-info.html

[2]http://www.alberton.info/postgresql_table_audit.html

[3]http://jimmyg.org/blog/2007/audit-tables-in-postgresql-with-debian.html

Mas, na correria do dia a dia temos que focar nas prioridades, e as minhas prioridades no caso estavam sendo o meu trabalho e o MBA.
Este último no qual eu terminei e resolvi criar este post.

MBA em Gestão de Projetos

Após concluir a graduação no final de 2009 eu não queria perder o ritmo de estudos, então na primeira oportunidade, claro que de acordo com minhas necessidades e possibilidades,
resolvi encarar mais um curso, desta vez de especialização em uma área que gosto muito, que é a Gestão de Projetos. No meu caso, claro, Projetos de Software.

Antes de comentar sobre a minha impressão a respeito do curso, vamos dar uma olhada na grade do curso:

• Gerenciamento de Projetos;
• Gestão Financeira;
• Gestão por Processos e Qualidade;
• Gestão Estratégia da Informação
• Gestão de Pessoas
• Avaliação de Projetos e de Riscos
• Gestão de Custos e Preços
• Gestão de Aquisições e Contratos
• Ferramentas de Software para Gestão de Projetos
• Metodologia da Pesquisa Científica
• Artigo Científico

São disciplinas interessantes em sua maioria. Claro, umas mais que outras, mas em cada uma delas tem alguns pontos interessantes.

Das disciplinas da grade as que mais achei interessante foram Gestão Financeira, Gestão por Processos e Qualidade, Gestão de Pessoas, Avaliação de Projetos e Riscos, Gestão de Custos e Preços e Gestão de Aquisição e Contratos. Sem dúvida alguma para quem trabalha em qualquer tipo de projeto e seja ele um software ou não estes temas trazem informações muito relevantes para aplicarmos no dia a dia.

Eu não quero entrar em detalhes sobre o curso e nem sobre as matérias neste post porque se prolongaria de mais. Mas eu estou pensando em criar um post para cada uma destas disciplinas mais interessantes para abordar um pouco sobre cada uma delas.

Fica pra um próximo. Por agora, só gostaria mesmo de afirmar que mais um objetivo foi concluído e abaixo está a prova do sucesso.

Até a próxima.

Essa foi a primeira vez que o evento foi transmitido via twitcam, e isso foi legal pois tanto as pessoas que se inscreveram para participar ao vivo quanto as que estavam em qualquer lugar do universo puderam assistir todas as palestras e interagir com as mesmas.

Como de costume, vou colocar o slide aqui para que as pessoas que participaram possam baixar o material e pegar meu contato para retirar dúvidas.

Uma das palestras proferidas no evento foi a minha, sobre TV Digital Interativa, e pude ver que em todos os lugares o interesse pelo assunto é grande e as pessoas ainda desconhecem muito sobre o assunto.

Portanto, devo levar esta palestra e até mesmo cursos completos para mais lugares do país.

Sim, o festival chama-se Latino-Americano, mas esse ano já tivemos em diversos outros continentes, como Europeu e Norte Americano.

No próximo ano o evento deverá ainda ter a sigla FLISOL mas seu nome deverá mudar. Coisas que ainda estão sendo discutidas pela comunidade.

Mas voltando ao objetivo principal do post, vou apenas fazer alguns comentários do que tivemos nesse ano no evento, algumas coisas boas e outras nem tanto.

Primeira coisa a ser abordada, é que conseguimos realizar este evento praticamente do dia para a noite. Tudo foi feito um pouco nas pressas, pois todos os membros da organização além de trabalhar no seu dia-a-dia com TI, também são apaixonados pelo que fazem. E isso faz com que nos envolvamos em diversas coisas ao mesmo tempo e faz com que não tenhamos tanto tempo assim para nos dedicarmos a algumas delas como deveríamos, já que infelizmente os dias possuem “apenas” 24 horas.

Mas no final, tudo deu relativamente certo, e o melhor de tudo é que podemos dessa forma apresentar diversas tecnologias para a comunidade local, aumentar o network, fazer novos amigos e ainda ajudar pessoas carentes com os alimentos arrecadados durante as inscrições .

Esse ano tivemos os seguintes mini-cursos:

1. Desenvolvendo Aplicações para TV Digital Interativa.
2. Computação Forense.
3. Python – A Primeira Mordida.

Todos os cursos tiveram boa aceitação pelo público, e tivemos muitos participantes. Mas claro, como na grande maioria dos eventos que já participei, mais pessoas se inscrevem do que as que realmente comparecem e participam. Isso no caso de cursos de tecnologia, onde temos poucos lugares equipados com computadores ou outros equipamentos que venhamos a precisar prejudica, e muito, aqueles que gostariam de participar mas não o fizeram por falta de vagas.

Tivemos ainda as seguintes palestras:

1. Desenvolvimento Mobile Web & Software Livre.
2. Começando com Linux.
3. Desenvolvendo Jogos 2D e 3D para Android.
4. A Maneira Ruby de Entregar Software.
5. Robótica para Humanos.
6. O Mercado e a Revolução do Software Livre.

Como podem ver, a temática foi bem variada e pudemos dessa forma agradar tanto gregos quanto troianos.

Durante os mini-cursos, palestras, coffee break e pós evento tivemos um bom feedback de muitos participantes, e com
isso poderemos traçar as metas para os próximos eventos que virão.

Claro, tivemos alguns problemas como acontece geralmente nos vários eventos pelo mundo afora, mas no final, tudo deu certo. E com isso também vamos aprendendo para que nos próximos façamos melhor.

ESTATÍSTICAS DO FLISOL – CAMPO GRANDE – MS

Total de inscritos nas palestras = 334
Total de inscritos mini-curso: 177
Total de inscritos no mini-curso “Desenvolvimento para TV Digital Interativa” = 46
Total de inscritos no mini-curso “Computação Forense” = 88
Total de inscritos no mini-curso “Python – A primeira mordida” = 36

Para finalizar, deixo algumas fotos do evento, para quem quiser ter uma ideia melhor de como foi, que o faça com as imagens.

Ah!, antes que me esqueça. Hoje conseguimos também algumas fotos da entrega dos alimentos que foram arrecadados durante o evento. Não sei ao certo quantos quilos conseguimos arrecadar, mas pelas fotos dá para ver que conseguimos ajudar diversas pessoas.

E isso que me deixa ainda mais feliz, e espero que fiquem também e que continuem participando cada vez mais.

Até o momento, cerca de 50 pessoas fizeram este curso, e novas turmas virão pois o interesse está sendo muito grande.

Claro que somente os slides não substituem a conversa e as ideias trocadas entre todos os participantes, incluindo eu. Mas estarei sempre por aqui para tirar dúvidas de todos que tiverem interesse nesta fantástica tecnologia.

Primeiro dia:

Segundo dia:

Terceiro dia:

Então, como estou refazendo a casa o blog, resolvi postar aqui o slide do slideshare.

Então, preparem-se para fortes emoções… ou nem tanto.

See you.